Added HairBlending shader pass;

Added HairBlendingSetting in UTSRenderPassSetting;
Added MaterialType to UTS;
Added MaterialFeature scope to UTS material editor;

Merged HairBlendingPass and HairShadowPass into UTSPass;

Fixed the bug that character box light can not update rotation correctly according to bound light source;

Runtime/HDRP/BoxLightAdjustment.cs

@@ -26,10 +26,7 @@ namespace Misaki.HdrpToon
 
         public Transform trackedTransform;
         public bool followGameObjectPosition = false;
-        public bool followGameObjectRotation = false;
-
-        public Vector3 positionOffset;
-        public Quaternion rotationOffset;
+        public float distanceOffset = 20.0f;
 
         [CreateProperty]
         public Light BindingSourceLight
@@ -64,8 +61,8 @@ namespace Misaki.HdrpToon
                     return;
                 }
 
-                UpdateShadowLayer(_bindingSourceLightData, _layerMask, value);
-                UpdateShadowLayer(_targetBoxLightData, _layerMask, value);
+                UpdateShadowLayer(_bindingSourceLightData, value);
+                UpdateShadowLayer(_targetBoxLightData, value);
 
                 _layerMask = value;
             }
@@ -92,13 +89,9 @@ namespace Misaki.HdrpToon
         {
             Initialize();
         }
-        // Start is called before the first frame update
-        private void Start()
-        {
-        }
 
         // Update is called once per frame
-        private void LateUpdate()
+        private void Update()
         {
             Initialize();
 
@@ -125,16 +118,12 @@ namespace Misaki.HdrpToon
             _targetBoxLight.enabled = _bindingSourceLight.enabled;
             _targetBoxLight.intensity = _bindingSourceLight.intensity;
 
-            if (trackedTransform != null)
+            if (trackedTransform != null && followGameObjectPosition)
             {
-                if (followGameObjectPosition)
-                {
-                    _targetBoxLight.transform.position = trackedTransform.transform.position + positionOffset;
-                }
-                if (followGameObjectRotation)
-                {
-                    _targetBoxLight.transform.rotation = trackedTransform.transform.rotation * rotationOffset;
-                }
+                var desiredPosition = trackedTransform.position - _bindingSourceLight.transform.forward * distanceOffset;
+
+                _targetBoxLight.transform.position = desiredPosition;
+                _targetBoxLight.transform.rotation = _bindingSourceLight.transform.rotation;
             }
         }
 
@@ -187,7 +176,7 @@ namespace Misaki.HdrpToon
 #if UNITY_EDITOR
             Undo.RegisterCreatedObjectUndo(lightGameObject, "Created Boxlight adjustment");
 #endif
-            var hdLightData = lightGameObject.AddHDLight(LightType.Box);
+            var hdLightData = lightGameObject.AddHDLight(UnityEngine.LightType.Box);
             // light size
             hdLightData.SetBoxSpotSize(new Vector2(10.0f, 10.0f)); // Size should be culculated with more acculacy?
             var boxLightAdjustment = lightGameObject.GetComponent<BoxLightAdjustment>();
@@ -228,12 +217,11 @@ namespace Misaki.HdrpToon
             return lightGameObject;
         }
 
-        private void UpdateShadowLayer(HDAdditionalLightData lightData, uint oldValue, uint newValue)
+        private void UpdateShadowLayer(HDAdditionalLightData lightData, uint newValue)
         {
             lightData.linkShadowLayers = false;
-            var oldShadowLayer = lightData.GetShadowLayers();
-            oldShadowLayer &= ~oldValue;
-            var newShadowLayer = oldShadowLayer | newValue;
+            var lightLayer = lightData.GetLightLayers();
+            var newShadowLayer = lightLayer | newValue | UnityEngine.RenderingLayerMask.defaultRenderingLayerMask;
             lightData.SetShadowLightLayer((UnityEngine.Rendering.HighDefinition.RenderingLayerMask)newShadowLayer);
         }
 
@@ -256,8 +244,7 @@ namespace Misaki.HdrpToon
 
             if (_targetBoxLight != null)
             {
-                positionOffset = _targetBoxLight.transform.position - trackedTransform.transform.position;
-                rotationOffset = Quaternion.Inverse(trackedTransform.transform.rotation) * _targetBoxLight.transform.rotation;
+                distanceOffset = Mathf.Abs(Vector3.Distance(_targetBoxLight.transform.position, trackedTransform.transform.position));
             }
 
             _initialized = true;

Runtime/HDRP/Models/UTSRenderPassSettings.cs

@@ -5,17 +5,30 @@ using UnityEngine;
 
 namespace Misaki.HdrpToon
 {
-    [Serializable]
-    internal struct UTSOutlineSetting
+    internal enum BufferQuality
     {
-        public bool enable;
+        Low,
+        High
     }
 
     [Serializable]
     internal struct UtsHairShadowSetting
     {
         public bool enable;
-        public UTSHairShadowPass.ShadowQuality shadowQuality;
+        public BufferQuality quality;
+    }
+
+    [Serializable]
+    internal struct UtsHairBlendingSetting
+    {
+        public bool enable;
+        public BufferQuality quality;
+    }
+
+    [Serializable]
+    internal struct UTSOutlineSetting
+    {
+        public bool enable;
     }
 
     [CreateAssetMenu(fileName = "UTSRenderSetting", menuName = "UTS/RenderSetting")]
@@ -25,10 +38,12 @@ namespace Misaki.HdrpToon
         public const string UTS_RENDERING_SETTINGS_PATH = "Assets/Resources/Settings/UTSRenderSettings.asset";
         public const string UTS_RENDERING_SETTINGS_RESOURCES_PATH = "Settings/UTSRenderSettings";
 
-        [SerializeField]
-        internal UTSOutlineSetting outlineSetting;
         [SerializeField]
         internal UtsHairShadowSetting hairShadowSetting;
+        [SerializeField]
+        internal UtsHairBlendingSetting hairBlendingSetting;
+        [SerializeField]
+        internal UTSOutlineSetting outlineSetting;
 
         internal static UTSRenderPassSettings GetOrCreateSettings()
         {

Runtime/HDRP/Shaders/HDRPToon.shader

@@ -22,6 +22,9 @@ Shader "HDRP/Toon"
         _BaseColorMap("BaseColorMap", 2D) = "white" {}
         [HideInInspector] _BaseColorMap_MipInfo("_BaseColorMap_MipInfo", Vector) = (0, 0, 0, 0)
 
+        _HairBlendingMap("HairBlendingMap", 2D) = "black" {}
+
+        [KeywordEnum(OFF, FrontHair, Face, Eye)] _Material_Type("Material Type", Float) = 0
         [KeywordEnum(OFF, ST, ANISO, KK, TOON)] _PBR_Mode("PBR MODE", Float) = 0
         _Metallic("_Metallic", Range(0.0, 1.0)) = 0
         _Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5
@@ -330,8 +333,8 @@ Shader "HDRP/Toon"
         _EyeParallaxAmount("EyeParallaxAmount", Float) = 0.1
         
         // Eyebrow Seethrough
-        [Togle(_)] _Is_EyebrowSeethrough("_Is_EyebrowSeethrough", Float) = 0
-        _EyeBrowBlendingFactor("EyeBrowBlendingFactor", Float) = 0.5
+        [Togle(_)] _Is_HairBlendingTarget("_Is_HairBlendingTarget", Float) = 0
+        _HairBlendingFactor("EyeBrowBlendingFactor", Float) = 0.5
         
         //v.2.0.6
         _BaseColor_Step("BaseColor_Step", Range(0, 1)) = 0.5
@@ -516,8 +519,6 @@ Shader "HDRP/Toon"
     // Variant
     //-------------------------------------------------------------------------------------
 
-    #pragma shader_feature _HAIR_SHADOWS
-
     #pragma shader_feature_local _ALPHATEST_ON
     #pragma shader_feature_local _DEPTHOFFSET_ON
     #pragma shader_feature_local _DOUBLESIDED_ON
@@ -530,15 +531,6 @@ Shader "HDRP/Toon"
     #pragma shader_feature_local _NORMALMAP_TANGENT_SPACE
     #pragma shader_feature_local _ _REQUIRE_UV2 _REQUIRE_UV3
 
-    #pragma shader_feature_local _NORMALMAP
-    #pragma shader_feature_local _DISABLE_DECALS
-    #pragma shader_feature_local _DISABLE_SSR
-
-    #pragma shader_feature_local _MASKMAP
-    #pragma shader_feature_local _ANISOTROPYMAP
-    #pragma shader_feature_local _SDFShadow
-    #pragma shader_feature_local _SPECULARCOLORMAP
-
     #pragma shader_feature_local_fragment _ENABLE_FOG_ON_TRANSPARENT
     #pragma shader_feature_local _TRANSPARENT_WRITES_MOTION_VEC
 
@@ -963,7 +955,7 @@ Shader "HDRP/Toon"
 
 
             HLSLPROGRAM
-//            #pragma multi_compile _ UTS_DEBUG_SHADOWMAP_BINALIZATION
+            //#pragma multi_compile _ UTS_DEBUG_SHADOWMAP_BINALIZATION
             #pragma multi_compile _ DEBUG_DISPLAY
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED
@@ -974,9 +966,10 @@ Shader "HDRP/Toon"
             #pragma multi_compile SCREEN_SPACE_SHADOWS_OFF SCREEN_SPACE_SHADOWS_ON
             // Supported shadow modes per light type
             #pragma multi_compile SHADOW_LOW SHADOW_MEDIUM SHADOW_HIGH
+            #pragma multi_compile MATERIAL_TYPE_STANDARD MATERIAL_TYPE_FRONT_HAIR MATERIAL_TYPE_FACE MATERIAL_TYPE_EYE
             #pragma multi_compile _PBR_Mode_OFF _PBR_Mode_ST _PBR_Mode_ANISO _PBR_Mode_KK _PBR_Mode_TOON
             #define LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
-//	    #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+            //#pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
             #define AREA_SHADOW_LOW
             #define SHADERPASS SHADERPASS_FORWARD
             // In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
@@ -998,23 +991,27 @@ Shader "HDRP/Toon"
             //Probe volume
             #pragma multi_compile PROBE_VOLUMES_OFF PROBE_VOLUMES_L1 PROBE_VOLUMES_L2
 
-            // Sample Face Shadow
+            #pragma shader_feature ENABLE_UTS_HAIR_SHAOW
+            #pragma shader_feature ENABLE_UTS_HAIR_BLENDING
+
+            #pragma shader_feature_local _MASKMAP
+            #pragma shader_feature_local _NORMALMAP
+            #pragma shader_feature_local _ANISOTROPYMAP
+            #pragma shader_feature_local _SPECULARCOLORMAP
+
+            #pragma shader_feature_local _SDFShadow
             #pragma shader_feature_local _RECEIVE_HAIR_SHADOW
-            // Eye parallax
-            #pragma shader_feature_local _EYE_PARALLAX
-            // Eyebrow Blending with hair
-            #pragma shader_feature_local _EYEBROW_SEETHROUGH
 
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl"
 
-        #ifdef DEBUG_DISPLAY
-        # if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
-            #include "DebugDisplay.hlsl"
-        # else
-            #include "DebugDisplayHDRP7.hlsl"
-        # endif
-        #endif
+            #ifdef DEBUG_DISPLAY
+            # if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
+                #include "DebugDisplay.hlsl"
+            # else
+                #include "DebugDisplayHDRP7.hlsl"
+            # endif
+            #endif
 
             // The light loop (or lighting architecture) is in charge to:
             // - Define light list
@@ -1032,16 +1029,16 @@ Shader "HDRP/Toon"
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl"
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/ShaderPass/LitSharePass.hlsl"
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitData.hlsl"
-        #ifdef DEBUG_DISPLAY
-        # if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
-            #include "ShaderPassForward.hlsl"
-        # else
-            #include "ShaderPassForwardHDRP7.hlsl"
-        # endif
-        #else
-            #include "UtsLightLoop.hlsl"
-            #include "ShaderPassForwardUTS.hlsl"
-        #endif
+            #ifdef DEBUG_DISPLAY
+            # if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
+                #include "ShaderPassForward.hlsl"
+            # else
+                #include "ShaderPassForwardHDRP7.hlsl"
+            # endif
+            #else
+                #include "UtsLightLoop.hlsl"
+                #include "ShaderPassForwardUTS.hlsl"
+            #endif
 
             #pragma vertex Vert
             #pragma fragment Frag
@@ -1110,7 +1107,6 @@ Shader "HDRP/Toon"
             Cull Front
             Blend SrcAlpha OneMinusSrcAlpha
 
-
             HLSLPROGRAM
 
 
@@ -1185,6 +1181,39 @@ Shader "HDRP/Toon"
 
             ENDHLSL
         }
+
+        Pass
+        {
+            Name "HairBlendingTarget"
+            Tags{ "LightMode" = "HairBlendingTarget" }
+
+            Cull[_CullMode]
+
+            ZClip [_ZClip]
+            ZWrite On
+            ZTest LEqual
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_FORWARD
+
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/ShaderPass/LitSharePass.hlsl"
+            #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitData.hlsl"
+
+            #ifdef DEBUG_DISPLAY
+                #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
+            #endif
+
+            #include "HDRPToonHead.hlsl"
+            #include "HDRPToonHairBlending.hlsl"
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            ENDHLSL
+        }
     }
 
     SubShader

Runtime/HDRP/Shaders/HDRPToonHairBlending.hlsl

@@ -0,0 +1,127 @@
+#undef unity_ObjectToWorld 
+#undef unity_WorldToObject 
+
+#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/MotionVectorVertexShaderCommon.hlsl"
+
+            // PackedVaryingsType
+            // https://github.com/Unity-Technologies/Graphics/blob/e4117c07b479adafed38237f3407a363eefb4590/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/VertMesh.hlsl#L120
+
+            PackedVaryingsType Vert(AttributesMesh inputMesh, AttributesPass inputPass)
+            {
+                // VaryingsType
+                // https://github.com/Unity-Technologies/Graphics/blob/e4117c07b479adafed38237f3407a363eefb4590/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/VertMesh.hlsl#L118
+
+                VaryingsType varyingsType;
+                varyingsType.vmesh = VertMesh(inputMesh);
+
+                return MotionVectorVS(varyingsType, inputMesh, inputPass);
+            }
+
+#else // _WRITE_TRANSPARENT_MOTION_VECTOR
+
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/VertMesh.hlsl"
+
+PackedVaryingsType Vert(AttributesMesh inputMesh)
+{
+    VaryingsType varyingsType;
+    varyingsType.vmesh = VertMesh(inputMesh);
+
+    return PackVaryingsType(varyingsType);
+}
+
+#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
+
+
+
+#ifdef UNITY_VIRTUAL_TEXTURING
+#define VT_BUFFER_TARGET SV_Target1
+#define EXTRA_BUFFER_TARGET SV_Target2
+#else
+#define EXTRA_BUFFER_TARGET SV_Target1
+#endif
+
+
+
+void Frag(PackedVaryingsToPS packedInput,
+#ifdef OUTPUT_SPLIT_LIGHTING
+            out float4 outColor : SV_Target0,  // outSpecularLighting
+#ifdef UNITY_VIRTUAL_TEXTURING
+            out float4 outVTFeedback : VT_BUFFER_TARGET,
+#endif
+            out float4 outDiffuseLighting : EXTRA_BUFFER_TARGET,
+            OUTPUT_SSSBUFFER(outSSSBuffer)
+#else
+            out float4 outColor : SV_Target0
+#ifdef UNITY_VIRTUAL_TEXTURING
+            , out float4 outVTFeedback : VT_BUFFER_TARGET
+#endif
+#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
+            , out float4 outMotionVec : EXTRA_BUFFER_TARGET
+#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
+#endif // OUTPUT_SPLIT_LIGHTING
+#ifdef _DEPTHOFFSET_ON
+            , out float outputDepth : SV_Depth
+#endif
+            )
+{
+    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(packedInput);
+    FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
+#ifdef _IS_CLIPPING_MASK
+    if (_ClippingMaskMode != 0)
+    {
+        discard;
+    }
+#endif
+#ifdef _IS_CLIPPING_MATTE
+    if (_ClippingMatteMode != 0)
+    {
+        discard;
+    }
+#endif // _IS_CLIPPING_MATTE
+#if defined(UTS_DEBUG_SHADOWMAP_NO_OUTLINE)
+    discard;
+#endif
+
+    
+
+    //v.2.0.5
+    if (_ZOverDrawMode > 0.99f)
+    {
+#ifdef _DEPTHOFFSET_ON
+        outputDepth = posInput.deviceDepth;
+#endif
+#ifdef UNITY_VIRTUAL_TEXTURING
+
+        outVTFeedback = builtinData.vtPackedFeedback;
+#endif
+        outColor = float4(1.0f, 1.0f, 1.0f, 1.0f); // but nothing should be drawn except Z value as colormask is set to 0
+        return;
+    }
+    _Color = _BaseColor;
+    float4 objPos = mul(unity_ObjectToWorld, float4(0, 0, 0, 1));
+    float4 Set_UV0 = input.texCoord0;
+    
+    // The following temporary definition of unity_AmbientEquator is for HDRP only.
+    //float4 unity_AmbientEquator = float4(0.05, 0.05, 0.05, 1.0); //Todo.
+    //v.2.0.9
+    //float3 envLightSource_GradientEquator = unity_AmbientEquator.rgb > 0.05 ? unity_AmbientEquator.rgb : half3(0.05, 0.05, 0.05);
+    float3 envLightSource_GradientEquator = ShadeSH9(float4(0, 1, 0, 0));
+    float3 envLightSource_SkyboxIntensity = max(
+        SampleBakedGI_UTS_OutLine(objPos.xyz, float3(0.0, 0.0, 0.0), input.texCoord1.xy, input.texCoord2.xy),
+        SampleBakedGI_UTS_OutLine(objPos.xyz, float3(0.0, -1.0, 0.0), input.texCoord1.xy, input.texCoord2.xy)
+        ).rgb;
+    float3 ambientSkyColor = envLightSource_SkyboxIntensity.rgb > 0.0 ? envLightSource_SkyboxIntensity : envLightSource_GradientEquator;
+    ambientSkyColor *= GetCurrentExposureMultiplier();
+
+    float4 _BlendingTex_var = SAMPLE_TEXTURE2D(_HairBlendingMap, sampler_HairBlendingMap, TRANSFORM_TEX(Set_UV0, _MainTex));
+    outColor = float4(_BlendingTex_var.rgb * ambientSkyColor, _BlendingTex_var.a);
+    
+#ifdef _DEPTHOFFSET_ON
+    outputDepth = posInput.deviceDepth;
+#endif
+#ifdef UNITY_VIRTUAL_TEXTURING
+    outVTFeedback = builtinData.vtPackedFeedback;
+#endif
+}
+// End of File

Runtime/HDRP/Shaders/HDRPToonHairBlending.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a528382509a1bca4b9da190eb68e40d4
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/HDRP/Shaders/ShaderPassForwardUTS.hlsl

@@ -194,7 +194,7 @@ void Frag(PackedVaryingsToPS packedInput,
 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 
-#ifdef _EYE_PARALLAX
+#ifdef MATERIAL_TYPE_EYE
         // Must have view Dir to work
         float2 viewT = TransformObjectToTangent(V, input.tangentToWorld);
         float2 parallaxOffset = viewT;
@@ -878,7 +878,7 @@ void Frag(PackedVaryingsToPS packedInput,
     // We directly calculate custome main light during the light loop in upper code to avoid extra calculation
     //customMainLight = GetCustomMainLightData(builtinData, mainPunctualLight);
 
-#if _SDFShadow || _RECEIVE_HAIR_SHADOW
+#if _SDFShadow || (_RECEIVE_HAIR_SHADOW && ENABLE_UTS_HAIR_SHAOW)
     float3 defaultLightDirection = normalize(UNITY_MATRIX_V[2].xyz + UNITY_MATRIX_V[1].xyz);
     float3 defaultLightColor = saturate(max(float3(0.05, 0.05, 0.05) * _Unlit_Intensity, max(ShadeSH9(float4(0.0, 0.0, 0.0, 1.0)), ShadeSH9(float4(0.0, -1.0, 0.0, 1.0)).rgb) * _Unlit_Intensity));
 
@@ -910,7 +910,7 @@ void Frag(PackedVaryingsToPS packedInput,
     utsAggregateLighting.directSpecular += _SDFNoseHighlightCoef * SDFNoseHighlight(angle, sdfRes.g, rightside, SDF_UV) * lightColor;
 #endif
 
-#ifdef _RECEIVE_HAIR_SHADOW
+#if _RECEIVE_HAIR_SHADOW && ENABLE_UTS_HAIR_SHAOW
     // 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)));
     
@@ -921,6 +921,10 @@ void Frag(PackedVaryingsToPS packedInput,
         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 = (input.positionSS.xy + 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.
@@ -958,29 +962,13 @@ void Frag(PackedVaryingsToPS packedInput,
     outColor = float4(outColor.rgb, Set_Opacity * ApplyChannelAlpha(channelAlpha));
 #endif
 
-#ifdef _EYEBROW_SEETHROUGH
-    // By Suomi, 20230915
-    // The eyebrow should use transparent pass and utilize the hair depth texture we have from HairShadowPass
-    float2 samplingPoint = posInput.positionNDC;
-    float cDepth = SampleCameraDepth(samplingPoint); // Camera Depth. At transparent queue we should have all the opaque object by now
-    float mDepth = posInput.deviceDepth; // Depth of this fragment
-    float3 hDepth = SAMPLE_TEXTURE2D(_HairShadowTex, s_trilinear_clamp_sampler, samplingPoint); // r: Depth of hair g: Depth of Eyebrow
-    
-    float hairPixel = step(0.001, hDepth.r);
-    float magic = 0.075;
-    mDepth = hairPixel > 0.1 ? max(hDepth.r, mDepth) + magic : mDepth; // Move this part of eyebrow in front of the hair
-    // Added a max here to prevent sampling of hair in the back
-    
-    if(cDepth - mDepth > 0.02) // Manual Depth Test
-    {
-        discard;
-    }
-    
-    outColor.a = _EyeBrowBlendingFactor;
-    outColor.a = hairPixel > 0.01 ? outColor.a : 1 ;
+#if MATERIAL_TYPE_FRONT_HAIR && ENABLE_UTS_HAIR_BLENDING
+    float2 screenUV = posInput.positionNDC * _HairBlendingRTHandleScale.xy;
+    float4 hairBlendingMap = SAMPLE_TEXTURE2D(_HairBlendingTex, s_trilinear_clamp_sampler, screenUV);
+    outColor.rgb = lerp(outColor.rgb, hairBlendingMap.rgb, hairBlendingMap.a * _HairBlendingFactor);
 #endif
 
-#if defined(UTS_DEBUG_SHADOWMAP) || defined(UTS_DEBUG_SELFSHADOW)
+#if UTS_DEBUG_SHADOWMAP || UTS_DEBUG_SELFSHADOW
     outColor.rgb = 1;
 #ifdef UTS_DEBUG_SELFSHADOW
     outColor.rgb = min(finalColor, outColor.rgb);

Runtime/HDRP/Shaders/UtsHdrpProperties.hlsl

@@ -30,6 +30,9 @@ SAMPLER(sampler_DiffuseLightingMap);
 TEXTURE2D(_BaseColorMap);
 SAMPLER(sampler_BaseColorMap);
 
+TEXTURE2D(_HairBlendingMap);
+SAMPLER(sampler_HairBlendingMap);
+
 TEXTURE2D(_MaskMap);
 SAMPLER(sampler_MaskMap);
 TEXTURE2D(_BentNormalMap); // Reuse sampler from normal map
@@ -81,7 +84,7 @@ TEXTURE2D(_SDFShadowTex);
 SAMPLER(sampler_SDFShadowTex);
 
 TEXTURE2D(_HairShadowTex);
-//SAMPLER(sampler_HairShadowTex); //registered number of this sampler is more than 16, so we can't use this sampler, use s_trilinear_clamp_sampler instead
+TEXTURE2D(_HairBlendingTex);
 
 #else
 
@@ -350,4 +353,6 @@ float _HairShadowDistance;
 float _HairShadowDistanceScaleFactor;
 float _HairShadowDepthBias;
 float _HairShadowFadeInDistance;
-float _HairShadowFadeOutDistance;
+float _HairShadowFadeOutDistance;
+
+float4 _HairBlendingRTHandleScale;

Runtime/HDRP/Shaders/UtsUnityPerMaterial.hlsl

@@ -23,7 +23,7 @@ float _SDFNoseHighlightCoef;
 float _SDFNoseHighlightSmoothRange;
 
 float _EyeParallaxAmount;
-float _EyeBrowBlendingFactor;
+float _HairBlendingFactor;
 
 float _BaseColor_Step;
 float _BaseShade_Feather;

Runtime/HDRP/UTS Renderer/UTSHairShadowPass.cs

@@ -10,12 +10,6 @@ namespace Misaki.HdrpToon
     [HideInInspector]
     internal class UTSHairShadowPass : DrawRenderersCustomPass
     {
-        public enum ShadowQuality
-        {
-            Low,
-            High
-        }
-
         private const string Hair_Shadow_RTHandle_Scale_Prop_Name = "_HairShadowRTHandleScale";
         private const string Hair_Shadow_Distance_Prop_Name = "_HairShadowDistance";
         private const string Hair_Shadow_Distance_Scale_Prop_Name = "_HairShadowDistanceScaleFactor";
@@ -23,13 +17,13 @@ namespace Misaki.HdrpToon
         private const string Hair_Shadow_FadeIn_Prop_Name = "_HairShadowFadeInDistance";
         private const string Hair_Shadow_Fade_Out_Prop_Name = "_HairShadowFadeOutDistance";
 
-        private const string Output_RT_Name = "_HairShadowTex";
+        private const string Output_RT_Prop_Name = "_HairShadowTex";
 
         private RTHandle _outputRTHandle;
         private bool _needReallocate;
 
-        private ShadowQuality _shadowQuality = ShadowQuality.High;
-        internal ShadowQuality CurrentShadowQuality
+        private BufferQuality _shadowQuality = BufferQuality.High;
+        internal BufferQuality CurrentShadowQuality
         {
             get => _shadowQuality;
             set
@@ -60,21 +54,21 @@ namespace Misaki.HdrpToon
 
             var scale = _shadowQuality switch
             {
-                ShadowQuality.Low => new Vector2(0.5f, 0.5f),
-                ShadowQuality.High => Vector2.one,
+                BufferQuality.Low => new Vector2(0.5f, 0.5f),
+                BufferQuality.High => Vector2.one,
                 _ => Vector2.zero
             };
 
             var format = _shadowQuality switch
             {
-                ShadowQuality.Low => GraphicsFormat.D16_UNorm,
-                ShadowQuality.High => GraphicsFormat.D32_SFloat,
+                BufferQuality.Low => GraphicsFormat.D16_UNorm,
+                BufferQuality.High => GraphicsFormat.D32_SFloat,
                 _ => GraphicsFormat.D16_UNorm
             };
 
             _outputRTHandle?.Release();
-            _outputRTHandle = RTHandles.Alloc(scale, colorFormat: format, filterMode: FilterMode.Bilinear, wrapMode: TextureWrapMode.Clamp, isShadowMap: true, name: Output_RT_Name);
-            Shader.SetGlobalTexture(Output_RT_Name, _outputRTHandle);
+            _outputRTHandle = RTHandles.Alloc(scale, colorFormat: format, filterMode: FilterMode.Bilinear, wrapMode: TextureWrapMode.Clamp, isShadowMap: true, useDynamicScale: true, name: Output_RT_Prop_Name);
+            Shader.SetGlobalTexture(Output_RT_Prop_Name, _outputRTHandle);
 
             _needReallocate = false;
         }
@@ -102,18 +96,11 @@ namespace Misaki.HdrpToon
                 return;
             }
 
-            var mask = RenderStateMask.Nothing;
-            var stateBlock = new RenderStateBlock(mask)
-            {
-                depthState = new DepthState(true, CompareFunction.LessEqual),
-            };
-
             var result = new RendererListDesc(UtsShaderPassName.hairShadowCasterPassId, ctx.cullingResults, ctx.hdCamera.camera)
             {
                 renderQueueRange = GetRenderQueueRange(RenderQueueType.All),
                 sortingCriteria = SortingCriteria.CommonOpaque,
                 excludeObjectMotionVectors = false,
-                stateBlock = stateBlock,
             };
 
             CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, ctx.renderContext.CreateRendererList(result));

Runtime/HDRP/UTS Renderer/UTSOutlinePass.cs

@@ -22,21 +22,12 @@ namespace Misaki.HdrpToon
 
             Shader.SetGlobalFloat("_Outline_MaxWidth", utsRenderer.outlineMaxWidth.value * 0.01f);
 
-            var mask = RenderStateMask.Nothing;
-            var stateBlock = new RenderStateBlock(mask)
-            {
-                depthState = new DepthState(depthWrite, depthCompareFunction),
-                // We disable the stencil when the depth is overwritten but we don't write to it, to prevent writing to the stencil.
-                stencilState = new StencilState(false),
-            };
-
             var renderConfig = HDUtils.GetRendererConfiguration(false, false);
             var result = new UnityEngine.Rendering.RendererUtils.RendererListDesc(UtsShaderPassName.outlinePassId, ctx.cullingResults, ctx.hdCamera.camera)
             {
                 rendererConfiguration = renderConfig,
                 renderQueueRange = GetRenderQueueRange(RenderQueueType.All),
                 excludeObjectMotionVectors = false,
-                stateBlock = stateBlock,
             };
 
             CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, ctx.renderContext.CreateRendererList(result));

Runtime/HDRP/UTS Renderer/UTSPass.cs

@@ -1,10 +1,14 @@
 using System;
+using UnityEditor;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.HighDefinition;
+using UnityEngine.Rendering.RendererUtils;
 
 namespace Misaki.HdrpToon
 {
+    [HideInInspector]
     internal class UTSPass : CustomPass
     {
         private const int Adjustment_Curve_Precision = 128;
@@ -17,18 +21,256 @@ namespace Misaki.HdrpToon
         private const string Toon_Light_Filter_Prop_Name = "_ToonLightHiCutFilter";
         private const string Ignore_Volume_Exposure_Prop_Name = "_ToonIgnoreExposureMultiplier";
 
+        private const string Hair_Shadow_RTHandle_Scale_Prop_Name = "_HairShadowRTHandleScale";
+        private const string Hair_Shadow_Distance_Prop_Name = "_HairShadowDistance";
+        private const string Hair_Shadow_Distance_Scale_Prop_Name = "_HairShadowDistanceScaleFactor";
+        private const string Hair_Shadow_Depth_Bias_Prop_Name = "_HairShadowDepthBias";
+        private const string Hair_Shadow_FadeIn_Prop_Name = "_HairShadowFadeInDistance";
+        private const string Hair_Shadow_Fade_Out_Prop_Name = "_HairShadowFadeOutDistance";
+
+        private const string Hair_Blending_RTHandle_Scale_Prop_Name = "_HairBlendingRTHandleScale";
+
+        private const string Output_RT_Prop_Name = "_HairShadowTex";
+        private const string Hair_Blending_Prop_Name = "_HairBlendingTex";
+
         private float _max;
         private float _min;
         private float[] _exposureArray;
 
+        private RTHandle _hairShadowRTHandle;
+        private bool _needReallocateHairShadow;
+
+        private RTHandle _hairBlendingRTHandle;
+        private bool _needReallocateHairBlending;
+
+        private bool _enableHairShadow;
+        public bool EnableHairShadow
+        {
+            get => _enableHairShadow;
+            set
+            {
+                if (_enableHairShadow == value)
+                {
+                    return;
+                }
+
+                _enableHairShadow = value;
+
+                if (_enableHairShadow)
+                {
+                    Shader.EnableKeyword("ENABLE_UTS_HAIR_SHAOW");
+                }
+                else
+                {
+                    Shader.DisableKeyword("ENABLE_UTS_HAIR_SHAOW");
+                    _hairShadowRTHandle?.Release();
+                }
+            }
+        }
+
+        private bool _enableHairBlending;
+        public bool EnableHairBlending
+        {
+            get => _enableHairBlending;
+            set
+            {
+                if (_enableHairBlending == value)
+                {
+                    return;
+                }
+
+                _enableHairBlending = value;
+
+                if (_enableHairBlending)
+                {
+                    Shader.EnableKeyword("ENABLE_UTS_HAIR_BLENDING");
+                }
+                else
+                {
+                    Shader.DisableKeyword("ENABLE_UTS_HAIR_BLENDING");
+                    _hairBlendingRTHandle?.Release();
+                }
+            }
+        }
+
+        private BufferQuality _hairShadowQuality = BufferQuality.High;
+        internal BufferQuality HairShadowQuality
+        {
+            get => _hairShadowQuality;
+            set
+            {
+                if (_hairShadowQuality == value)
+                {
+                    return;
+                }
+
+                _hairShadowQuality = value;
+                _needReallocateHairShadow = true;
+            }
+        }
+
+        private BufferQuality _hairBlendingQuality = BufferQuality.High;
+        internal BufferQuality HairBlendingQuality
+        {
+            get => _hairBlendingQuality;
+            set
+            {
+                if (_hairBlendingQuality == value)
+                {
+                    return;
+                }
+
+                _hairBlendingQuality = value;
+                _needReallocateHairBlending = true;
+            }
+        }
+
+        private bool ShouldReallocateHairShadowBuffer()
+        {
+            return _hairShadowRTHandle == null || _hairShadowRTHandle.rt == null || !_hairShadowRTHandle.rt.IsCreated() || _needReallocateHairShadow;
+        }
+
+        private void ReallocateHairShadowBuffer()
+        {
+#if UNITY_EDITOR
+            if (EditorApplication.isCompiling)
+            {
+                return;
+            }
+#endif
+
+            var scale = _hairShadowQuality switch
+            {
+                BufferQuality.Low => new Vector2(0.5f, 0.5f),
+                BufferQuality.High => Vector2.one,
+                _ => Vector2.zero
+            };
+
+            var format = _hairShadowQuality switch
+            {
+                BufferQuality.Low => GraphicsFormat.D16_UNorm,
+                BufferQuality.High => GraphicsFormat.D32_SFloat,
+                _ => GraphicsFormat.D16_UNorm
+            };
+
+            _hairShadowRTHandle?.Release();
+            _hairShadowRTHandle = RTHandles.Alloc(scale, colorFormat: format, isShadowMap: true, useDynamicScale: true, name: Output_RT_Prop_Name);
+            Shader.SetGlobalTexture(Output_RT_Prop_Name, _hairShadowRTHandle);
+
+            _needReallocateHairShadow = false;
+        }
+
+        private bool ShouldReallocateHairBlendingBuffer()
+        {
+            return _hairBlendingRTHandle == null || _hairBlendingRTHandle.rt == null || !_hairBlendingRTHandle.rt.IsCreated() || _needReallocateHairBlending;
+        }
+
+        private void ReallocateHairBlendingBuffer()
+        {
+#if UNITY_EDITOR
+            if (EditorApplication.isCompiling)
+            {
+                return;
+            }
+#endif
+
+            var format = _hairBlendingQuality switch
+            {
+                BufferQuality.Low => GraphicsFormat.R8G8B8A8_SNorm,
+                BufferQuality.High => GraphicsFormat.R8G8B8A8_SRGB,
+                _ => GraphicsFormat.R8G8B8A8_SRGB
+            };
+
+            _hairBlendingRTHandle?.Release();
+            _hairBlendingRTHandle = RTHandles.Alloc(Vector2.one, colorFormat: format, useDynamicScale: true, name: Hair_Blending_Prop_Name);
+            Shader.SetGlobalTexture(Hair_Blending_Prop_Name, _hairBlendingRTHandle);
+
+            _needReallocateHairBlending = false;
+        }
+
         protected override void Setup(ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             _exposureArray = new float[Adjustment_Curve_Precision];
+
+            ReallocateHairShadowBuffer();
+            ReallocateHairBlendingBuffer();
         }
 
         protected override void Execute(CustomPassContext ctx)
         {
             var utsRenderer = ctx.hdCamera.volumeStack.GetComponent<UTSRenderer>();
+
+            UpdateSceneEV(utsRenderer);
+            RenderHairShadow(ref ctx, utsRenderer);
+            RenderHairBlending(ref ctx);
+        }
+
+        private void RenderHairShadow(ref CustomPassContext ctx, UTSRenderer utsRenderer)
+        {
+            if (!_enableHairShadow)
+            {
+                return;
+            }
+
+            if (ShouldReallocateHairShadowBuffer())
+            {
+                ReallocateHairShadowBuffer();
+                return;
+            }
+
+            CoreUtils.SetRenderTarget(ctx.cmd, _hairShadowRTHandle, ClearFlag.DepthStencil);
+
+            var shouldRender = utsRenderer != null && utsRenderer.enableHairShadow.value && utsRenderer.state.value;
+            if (!shouldRender)
+            {
+                return;
+            }
+
+            var result = new RendererListDesc(UtsShaderPassName.hairShadowCasterPassId, ctx.cullingResults, ctx.hdCamera.camera)
+            {
+                renderQueueRange = GetRenderQueueRange(RenderQueueType.All),
+                sortingCriteria = SortingCriteria.CommonOpaque,
+                excludeObjectMotionVectors = false,
+            };
+
+            CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, ctx.renderContext.CreateRendererList(result));
+
+            Shader.SetGlobalVector(Hair_Shadow_RTHandle_Scale_Prop_Name, _hairShadowRTHandle.rtHandleProperties.rtHandleScale);
+            Shader.SetGlobalFloat(Hair_Shadow_Distance_Prop_Name, utsRenderer.shadowDistance.value);
+            Shader.SetGlobalFloat(Hair_Shadow_Distance_Scale_Prop_Name, utsRenderer.shadowDistanceScale.value);
+            Shader.SetGlobalFloat(Hair_Shadow_Depth_Bias_Prop_Name, utsRenderer.shadowDepthBias.value);
+            Shader.SetGlobalFloat(Hair_Shadow_FadeIn_Prop_Name, utsRenderer.shadowFadeIn.value);
+            Shader.SetGlobalFloat(Hair_Shadow_Fade_Out_Prop_Name, utsRenderer.shadowFadeOut.value);
+        }
+
+        private void RenderHairBlending(ref CustomPassContext ctx)
+        {
+            if (!_enableHairBlending)
+            {
+                return;
+            }
+
+            if (ShouldReallocateHairBlendingBuffer())
+            {
+                ReallocateHairBlendingBuffer();
+                return;
+            }
+
+            CoreUtils.SetRenderTarget(ctx.cmd, _hairBlendingRTHandle, ctx.cameraDepthBuffer, ClearFlag.Color);
+
+            var result = new RendererListDesc(UtsShaderPassName.hairBlendingTargetPassId, ctx.cullingResults, ctx.hdCamera.camera)
+            {
+                renderQueueRange = GetRenderQueueRange(RenderQueueType.All),
+                sortingCriteria = SortingCriteria.CommonOpaque,
+                excludeObjectMotionVectors = false,
+            };
+
+            CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, ctx.renderContext.CreateRendererList(result));
+            Shader.SetGlobalVector(Hair_Blending_RTHandle_Scale_Prop_Name, _hairBlendingRTHandle.rtHandleProperties.rtHandleScale);
+        }
+
+        private void UpdateSceneEV(UTSRenderer utsRenderer)
+        {
             if (utsRenderer == null)
             {
                 return;
@@ -86,6 +328,8 @@ namespace Misaki.HdrpToon
         protected override void Cleanup()
         {
             _exposureArray = null;
+            _hairShadowRTHandle?.Release();
+            _hairBlendingRTHandle?.Release();
         }
     }
 }

Runtime/HDRP/UTS Renderer/UTSRenderPassRegistrar.cs

@@ -11,7 +11,7 @@ namespace Misaki.HdrpToon
         private static UTSRenderPassSettings _renderSetting;
 
         private static UTSPass _utsPass;
-        private static UTSHairShadowPass _hairShadowPass;
+        //private static UTSHairShadowPass _hairShadowPass;
         private static UTSOutlinePass _outlinePass;
 
         static UTSRenderPassRegistrar() => RegisterCustomPasses();
@@ -32,22 +32,21 @@ namespace Misaki.HdrpToon
                 targetDepthBuffer = CustomPass.TargetBuffer.None,
             };
 
-            _hairShadowPass = new()
-            {
-                name = "UTS Hair Shadow Map",
-                targetColorBuffer = CustomPass.TargetBuffer.None,
-                targetDepthBuffer = CustomPass.TargetBuffer.None,
-            };
+            //_hairShadowPass = new()
+            //{
+            //    name = "UTS Hair Shadow Map",
+            //    targetColorBuffer = CustomPass.TargetBuffer.None,
+            //    targetDepthBuffer = CustomPass.TargetBuffer.None,
+            //};
 
             _outlinePass = new()
             {
                 name = "UTS Outline",
-                targetColorBuffer = CustomPass.TargetBuffer.None,
-                targetDepthBuffer = CustomPass.TargetBuffer.None,
+                targetColorBuffer = CustomPass.TargetBuffer.Camera,
+                targetDepthBuffer = CustomPass.TargetBuffer.Camera,
             };
 
             CustomPassVolume.RegisterUniqueGlobalCustomPass(CustomPassInjectionPoint.BeforeRendering, _utsPass);
-            CustomPassVolume.RegisterUniqueGlobalCustomPass(CustomPassInjectionPoint.AfterOpaqueDepthAndNormal, _hairShadowPass);
             CustomPassVolume.RegisterUniqueGlobalCustomPass(CustomPassInjectionPoint.BeforePostProcess, _outlinePass);
 
             NotifyRendererSettingChanged();
@@ -56,23 +55,21 @@ namespace Misaki.HdrpToon
         public static void UnregisterGlobalCustomPass()
         {
             CustomPassVolume.UnregisterGlobalCustomPass(_utsPass);
-            CustomPassVolume.UnregisterGlobalCustomPass(_hairShadowPass);
             CustomPassVolume.UnregisterGlobalCustomPass(_outlinePass);
         }
 
         public static void NotifyRendererSettingChanged()
         {
-            if (_hairShadowPass == null || _outlinePass == null)
+            if (_utsPass == null || _outlinePass == null)
             {
                 return;
             }
 
-            _hairShadowPass.enabled = _renderSetting.hairShadowSetting.enable;
-            _hairShadowPass.CurrentShadowQuality = _renderSetting.hairShadowSetting.shadowQuality;
-            if (!_renderSetting.hairShadowSetting.enable)
-            {
-                _hairShadowPass.Release();
-            }
+            _utsPass.EnableHairShadow = _renderSetting.hairShadowSetting.enable;
+            _utsPass.HairShadowQuality = _renderSetting.hairShadowSetting.quality;
+
+            _utsPass.EnableHairBlending = _renderSetting.hairBlendingSetting.enable;
+            _utsPass.HairBlendingQuality = _renderSetting.hairBlendingSetting.quality;
 
             _outlinePass.enabled = _renderSetting.outlineSetting.enable;
         }