Fixed the engergy conservation problem when pbr mode is toon.

Editor/MeterialEditor/Helpers/MaterialHelpers.cs

@@ -26,6 +26,16 @@ namespace Misaki.HdrpToon.Editor
             return (PBRMode)material.GetInteger(SurfaceOptions.PBR_MODE);
         }
 
+        public static MaterialType GetMaterialType(this Material material)
+        {
+            if (!material.HasProperty(SurfaceOptions.MATERIAL_TYPE))
+            {
+                return MaterialType.Standard;
+            }
+
+            return (MaterialType)material.GetInteger(SurfaceOptions.MATERIAL_TYPE);
+        }
+
         public static bool HasFeature(this Material material, SurfaceFeature feature)
         {
             if (!material.HasProperty(SurfaceOptions.SURFACE_FEATURE))
@@ -36,5 +46,10 @@ namespace Misaki.HdrpToon.Editor
             var value = (SurfaceFeature)material.GetInteger(SurfaceOptions.SURFACE_FEATURE);
             return (value & feature) != 0;
         }
+
+        public static bool IsHairBlendingTarget(this Material material)
+        {
+            return material.GetShaderPassEnabled(UtsShaderPassName.HAIR_BLENDING_TARGET_PASS_NAME);
+        }
     }
 }

Editor/MeterialEditor/UIScopes/AdvanceScope.cs

@@ -10,6 +10,8 @@ namespace Misaki.HdrpToon.Editor
     {
         private static class Properties
         {
+            public static MaterialProperty diffuseMin;
+
             public static MaterialProperty lightIntensityMultiplier;
             public static MaterialProperty clampLightColor;
 
@@ -18,6 +20,8 @@ namespace Misaki.HdrpToon.Editor
 
         private static class Styles
         {
+            public static readonly GUIContent diffuseMinText = new("Minimal diffuse contribution", "Specifies the minimum contribution of the base color to the diffuse light. Keep it 0 to make sure energy conservation.");
+
             public static readonly GUIContent lightIntensityMultiplierText = new("Light Intensity Multiplier", "Specifies the intensity multiplier of the light.");
             public static readonly GUIContent clampLightColorText = new("Clamp Light Color", "Specifies whether to clamp the light color.");
 
@@ -30,6 +34,8 @@ namespace Misaki.HdrpToon.Editor
 
         public override void LoadMaterialProperties()
         {
+            Properties.diffuseMin = FindProperty(MINIMAL_DIFFUSE_CONTRIBUTION);
+
             Properties.lightIntensityMultiplier = FindProperty(LIGHT_INTENSITY_MULTIPLIER);
             Properties.clampLightColor = FindProperty(CLAMP_LIGHT_COLOR);
 
@@ -38,6 +44,8 @@ namespace Misaki.HdrpToon.Editor
 
         protected override void DrawContent()
         {
+            editor.ShaderProperty(Properties.diffuseMin, Styles.diffuseMinText);
+
             editor.ShaderProperty(Properties.lightIntensityMultiplier, Styles.lightIntensityMultiplierText);
             editor.ShaderProperty(Properties.clampLightColor, Styles.clampLightColorText);
 

Editor/MeterialEditor/UIScopes/AmbientScope.cs

@@ -17,6 +17,10 @@ namespace Misaki.HdrpToon.Editor
             public static MaterialProperty indirectDiffuseMatCapMap;
             public static MaterialProperty indirectDiffuseMatCapLod;
 
+            public static MaterialProperty indirectDiffuseRampMap;
+            public static MaterialProperty indirectDiffuseRampIndex;
+            public static MaterialProperty indirectDiffuseRampPosition;
+
             public static MaterialProperty indirectDiffuseIntensity;
             public static MaterialProperty ssaoWeight;
             public static MaterialProperty ssgiWeight;
@@ -35,6 +39,9 @@ namespace Misaki.HdrpToon.Editor
 
             public static readonly GUIContent indirectDiffuseMatCapMapText = new("MatCap Map", "The material capture map for indirect diffuse evaluation, with the additional setting for controlling the LOD offset when sampling the indirect diffuse material capture map.");
 
+            public static readonly GUIContent indirectDiffuseRampMapText = new("Ramp Map", "The ramp map for indirect diffuse evaluation, with the additional setting for controlling the sampling index of the ramp map.");
+            public static readonly GUIContent indirectDiffuseRampPositionText = new("Ramp Position", "The ramp position for indirect diffuse evaluation.");
+
             public static readonly GUIContent indirectDiffuseIntensityText = new("Intensity", "The indirect diffuse color is added to the material color according to the intensity value.");
             public static readonly GUIContent ssaoWeightText = new("SSAO Weight", "The weight of SSAO.");
             public static readonly GUIContent ssgiWeightText = new("SSGI Weight", "The weight of SSGI.");
@@ -53,6 +60,10 @@ namespace Misaki.HdrpToon.Editor
             Properties.indirectDiffuseMatCapMap = FindProperty("_IndirectDiffuseMatCapMap");
             Properties.indirectDiffuseMatCapLod = FindProperty("_IndirectDiffuseMatCapLod");
 
+            Properties.indirectDiffuseRampMap = FindProperty("_IndirectDiffuseRampMap");
+            Properties.indirectDiffuseRampIndex = FindProperty("_IndirectDiffuseRampIndex");
+            Properties.indirectDiffuseRampPosition = FindProperty("_IndirectDiffuseRampPosition");
+
             Properties.indirectDiffuseIntensity = FindProperty("_IndirectDiffuseIntensity");
             Properties.ssaoWeight = FindProperty("_SSAOWeight");
             Properties.ssgiWeight = FindProperty("_SSGIWeight");
@@ -64,6 +75,36 @@ namespace Misaki.HdrpToon.Editor
             Properties.ssrWeight = FindProperty("_SSRWeight");
         }
 
+        private static void DrawIndirectDiffuseHeader()
+        {
+            EditorGUILayout.Space();
+            using var indentLevelScope = new EditorGUI.IndentLevelScope(-1);
+            EditorGUILayout.LabelField("Indirect Diffuse", EditorStyles.boldLabel);
+        }
+
+        private void DrawIndirectDiffuseProperties()
+        {
+            EditorGUILayout.Space();
+            editor.ShaderProperty(Properties.indirectDiffuseIntensity, Styles.indirectDiffuseIntensityText);
+            editor.ShaderProperty(Properties.ssaoWeight, Styles.ssaoWeightText);
+        }
+
+        private void DrawIndirectSpecularProperties()
+        {
+            EditorGUILayout.Space();
+            editor.ShaderProperty(Properties.indirectReflectionIntensity, Styles.indirectReflectionIntensityText);
+            editor.ShaderProperty(Properties.ssrWeight, Styles.ssrWeightText);
+        }
+
+        private static void DrawIndirectSpecularHeader()
+        {
+            EditorGUILayout.Space();
+            using (var indentLevelScope = new EditorGUI.IndentLevelScope(-1))
+            {
+                EditorGUILayout.LabelField("Indirect Specular", EditorStyles.boldLabel);
+            }
+        }
+
         protected override void DrawContent()
         {
             editor.ShaderProperty(Properties.indirectDiffuseMode, Styles.indirectDiffuseModeText);
@@ -74,41 +115,43 @@ namespace Misaki.HdrpToon.Editor
 
             if (indirectDiffuseMode != IndirectDiffuseMode.Off)
             {
-                EditorGUILayout.Space();
-                using (var indentLevelScope = new EditorGUI.IndentLevelScope(-1))
-                {
-                    EditorGUILayout.LabelField("Indirect Diffuse", EditorStyles.boldLabel);
-                }
+                DrawIndirectDiffuseHeader();
 
-                if (indirectDiffuseMode == IndirectDiffuseMode.Matcap)
-                {
-                    editor.TexturePropertySingleLine(Styles.indirectDiffuseMatCapMapText, Properties.indirectDiffuseMatCapMap, Properties.indirectDiffuseMatCapLod);
-                }
-
-                editor.ShaderProperty(Properties.indirectDiffuseIntensity, Styles.indirectDiffuseIntensityText);
-                editor.ShaderProperty(Properties.ssaoWeight, Styles.ssaoWeightText);
-
-                if (indirectDiffuseMode == IndirectDiffuseMode.IBL)
+                switch (indirectDiffuseMode)
                 {
+                    case IndirectDiffuseMode.IBL:
                         editor.ShaderProperty(Properties.ssgiWeight, Styles.ssgiWeightText);
-                }
+                        break;
+                    case IndirectDiffuseMode.Matcap:
+                        editor.TexturePropertySingleLine(Styles.indirectDiffuseMatCapMapText, Properties.indirectDiffuseMatCapMap, Properties.indirectDiffuseMatCapLod);
+                        break;
+                    case IndirectDiffuseMode.Ramp:
+                        editor.TexturePropertySingleLine(Styles.indirectDiffuseRampMapText, Properties.indirectDiffuseRampMap, Properties.indirectDiffuseRampIndex);
+                        editor.ShaderProperty(Properties.indirectDiffuseRampPosition, Styles.indirectDiffuseRampPositionText);
+                        break;
+                    default:
+                        break;
                 }
 
-            if (indirectSpecularMode != (int)IndirectSpecularMode.Off)
-            {
-                EditorGUILayout.Space();
-                using (var indentLevelScope = new EditorGUI.IndentLevelScope(-1))
-                {
-                    EditorGUILayout.LabelField("Indirect Specular", EditorStyles.boldLabel);
+                DrawIndirectDiffuseProperties();
             }
 
-                if (indirectSpecularMode == IndirectSpecularMode.Matcap)
+            if (indirectSpecularMode != IndirectSpecularMode.Off)
             {
+                DrawIndirectSpecularHeader();
+
+                switch (indirectSpecularMode)
+                {
+                    case IndirectSpecularMode.IBL:
+                        break;
+                    case IndirectSpecularMode.Matcap:
                         editor.TexturePropertySingleLine(Styles.indirectSpecularMatCapMapText, Properties.indirectSpecularMatCapMap, Properties.indirectSpecularMatCapLod);
+                        break;
+                    default:
+                        break;
                 }
 
-                editor.ShaderProperty(Properties.indirectReflectionIntensity, Styles.indirectReflectionIntensityText);
-                editor.ShaderProperty(Properties.ssrWeight, Styles.ssrWeightText);
+                DrawIndirectSpecularProperties();
             }
         }
     }

Editor/MeterialEditor/UIScopes/ShadingColorScope.cs

@@ -34,6 +34,8 @@ namespace Misaki.HdrpToon.Editor
             public static MaterialProperty sdfShadowLevel;
             public static MaterialProperty sdfSmoothLevel;
             public static MaterialProperty sdfHighlightStrength;
+
+            public static MaterialProperty hairBlendingFactor;
         }
 
         private static class Styles
@@ -59,6 +61,8 @@ namespace Misaki.HdrpToon.Editor
             public static readonly GUIContent shadingRampMaskMapText = new("Shading Ramp Mask Map", "A texture that contains the mask for the shading ramp map.");
 
             public static readonly GUIContent sdfHighlightStrengthText = new("SDF Highlight Strength", "Control the strength of the highlight in the SDF shading map.");
+
+            public static readonly GUIContent hairBlendingFactorText = new("Hair Blending Factor", "The blending factor for hair shading.");
         }
 
         protected override ShaderGUIExpandable ExpandableBit => ShaderGUIExpandable.ShadingColor;
@@ -108,6 +112,8 @@ namespace Misaki.HdrpToon.Editor
             Properties.sdfShadowLevel = FindProperty("_SDFShadowLevel");
             Properties.sdfSmoothLevel = FindProperty("_SDFShadowSmoothLevel");
             Properties.sdfHighlightStrength = FindProperty("_SDFHighlightStrength");
+
+            Properties.hairBlendingFactor = FindProperty("_HairBlendingFactor");
         }
 
         protected override void DrawContent()
@@ -144,6 +150,12 @@ namespace Misaki.HdrpToon.Editor
                 editor.ShaderProperty(Properties.sdfHighlightStrength, Styles.sdfHighlightStrengthText);
             }
 
+            if (materials.All(material => material.GetMaterialType() == MaterialType.FrontHair))
+            {
+                EditorGUILayout.Space();
+                editor.ShaderProperty(Properties.hairBlendingFactor, Styles.hairBlendingFactorText);
+            }
+
             EditorGUILayout.Space();
             editor.TextureScaleOffsetProperty(Properties.baseColorMap);
         }

Editor/MeterialEditor/UIScopes/SurfaceInputsScope.cs

@@ -12,28 +12,30 @@ namespace Misaki.HdrpToon.Editor
     {
         private static class Properties
         {
-            public static MaterialProperty NormalMap;
-            public static MaterialProperty NormalMapScale;
+            public static MaterialProperty normalMap;
+            public static MaterialProperty normalMapScale;
 
-            public static MaterialProperty MaskMap;
-            public static MaterialProperty Metallic;
-            public static MaterialProperty MetallicRemapMin;
-            public static MaterialProperty MetallicRemapMax;
-            public static MaterialProperty AORemapMin;
-            public static MaterialProperty AORemapMax;
-            public static MaterialProperty Smoothness;
-            public static MaterialProperty SmoothnessRemapMin;
-            public static MaterialProperty SmoothnessRemapMax;
+            public static MaterialProperty maskMap;
+            public static MaterialProperty metallic;
+            public static MaterialProperty metallicRemapMin;
+            public static MaterialProperty metallicRemapMax;
+            public static MaterialProperty aoRemapMin;
+            public static MaterialProperty aoRemapMax;
+            public static MaterialProperty smoothness;
+            public static MaterialProperty smoothnessRemapMin;
+            public static MaterialProperty smoothnessRemapMax;
 
-            public static MaterialProperty AnisotropyMap;
-            public static MaterialProperty Anisotropy;
-            public static MaterialProperty KKColor;
-            public static MaterialProperty BSDFContribution;
+            public static MaterialProperty anisotropyMap;
+            public static MaterialProperty anisotropy;
+            public static MaterialProperty kkColor;
+            public static MaterialProperty bsdfContribution;
 
-            public static MaterialProperty SpecularColorMap;
-            public static MaterialProperty SpecularColor;
-            public static MaterialProperty SpecularFeather;
-            public static MaterialProperty SpecularStep;
+            public static MaterialProperty specularColorMap;
+            public static MaterialProperty specularColor;
+            public static MaterialProperty specularFeather;
+            public static MaterialProperty specularStep;
+
+            public static MaterialProperty hairBlendingMap;
 
             public static MaterialProperty emissiveColorLDR;
             public static MaterialProperty emissiveColorMap;
@@ -45,21 +47,23 @@ namespace Misaki.HdrpToon.Editor
 
         private static class Styles
         {
-            public static readonly GUIContent NormalMapText = new("Normal Map", "A texture that dictates the bumpiness of the material.");
-            public static readonly GUIContent MaskMapText = new("Mask Map", "A texture that dictates the physical properties of the material. R channel for metallic, G channel for ambient occlusion, A channel for smoothness");
-            public static readonly GUIContent MetallicText = new("Metallic", "Specifies the metallic value of the material.");
-            public static readonly GUIContent MetallicRemap = new("Metallic Remap", "Remap the max and min value of metallic");
-            public static readonly GUIContent AORemap = new("AO Remap", "Remap the max and min value of ambient occlusion");
-            public static readonly GUIContent SmoothnessText = new("Smoothness", "Specifies the smoothness of the material.");
-            public static readonly GUIContent SmoothnessRemapText = new("Smoothness Remap", "Remap the max and min value of smoothness");
+            public static readonly GUIContent normalMapText = new("Normal Map", "A texture that dictates the bumpiness of the material.");
+            public static readonly GUIContent maskMapText = new("Mask Map", "A texture that dictates the physical properties of the material. R channel for metallic, G channel for ambient occlusion, A channel for smoothness");
+            public static readonly GUIContent metallicText = new("Metallic", "Specifies the metallic value of the material.");
+            public static readonly GUIContent metallicRemap = new("Metallic Remap", "Remap the max and min value of metallic");
+            public static readonly GUIContent aoRemap = new("AO Remap", "Remap the max and min value of ambient occlusion");
+            public static readonly GUIContent smoothnessText = new("Smoothness", "Specifies the smoothness of the material.");
+            public static readonly GUIContent smoothnessRemapText = new("Smoothness Remap", "Remap the max and min value of smoothness");
 
-            public static readonly GUIContent AnisotropyMapText = new("Anisotropy Map", "Specifies the anisotropy map of the material.");
+            public static readonly GUIContent anisotropyMapText = new("Anisotropy Map", "Specifies the anisotropy map of the material.");
 
-            public static readonly GUIContent KKColorText = new("KK specular Color", "Specifies the color of KK specular.");
-            public static readonly GUIContent BSDFContributionText = new("BSDF Contribution", "BSDF smoothness contribution, 1 means KK Hair smoothness will fully contribute bsdf calculation");
+            public static readonly GUIContent kkColorText = new("KK specular Color", "Specifies the color of KK specular.");
+            public static readonly GUIContent bsdfContributionText = new("BSDF Contribution", "BSDF smoothness contribution, 1 means KK Hair smoothness will fully contribute bsdf calculation");
 
-            public static readonly GUIContent SpecularColorMapText = new("Specular Color Map", "Specifies the specular color map of the material.");
-            public static readonly GUIContent SpecRemap = new("Specular Remap", "Feather and step value of Toon Specular");
+            public static readonly GUIContent specularColorMapText = new("Specular Color Map", "Specifies the specular color map of the material.");
+            public static readonly GUIContent specRemap = new("Specular Remap", "Feather and step value of Toon Specular");
+
+            public static readonly GUIContent hairBlenderMapText = new("Hair Blending Map", "Specifies the hair blending map of the material.");
 
             public static readonly GUIContent emissiveColorText = new("Emissive Color", "The color and color map to set for emissive effect.");
             public static readonly GUIContent albedoAffectEmissiveText = new("Albedo Affect Emissive", "Enable to affect emissive color with base color");
@@ -73,28 +77,30 @@ namespace Misaki.HdrpToon.Editor
 
         public override void LoadMaterialProperties()
         {
-            Properties.NormalMap = FindProperty("_NormalMap");
-            Properties.NormalMapScale = FindProperty("_NormalScale");
+            Properties.normalMap = FindProperty("_NormalMap");
+            Properties.normalMapScale = FindProperty("_NormalScale");
 
-            Properties.MaskMap = FindProperty("_MaskMap");
-            Properties.Metallic = FindProperty("_Metallic");
-            Properties.MetallicRemapMin = FindProperty("_MetallicRemapMin");
-            Properties.MetallicRemapMax = FindProperty("_MetallicRemapMax");
-            Properties.AORemapMin = FindProperty("_AORemapMin");
-            Properties.AORemapMax = FindProperty("_AORemapMax");
-            Properties.SmoothnessRemapMin = FindProperty("_SmoothnessRemapMin");
-            Properties.SmoothnessRemapMax = FindProperty("_SmoothnessRemapMax");
-            Properties.Smoothness = FindProperty("_Smoothness");
+            Properties.maskMap = FindProperty("_MaskMap");
+            Properties.metallic = FindProperty("_Metallic");
+            Properties.metallicRemapMin = FindProperty("_MetallicRemapMin");
+            Properties.metallicRemapMax = FindProperty("_MetallicRemapMax");
+            Properties.aoRemapMin = FindProperty("_AORemapMin");
+            Properties.aoRemapMax = FindProperty("_AORemapMax");
+            Properties.smoothnessRemapMin = FindProperty("_SmoothnessRemapMin");
+            Properties.smoothnessRemapMax = FindProperty("_SmoothnessRemapMax");
+            Properties.smoothness = FindProperty("_Smoothness");
 
-            Properties.AnisotropyMap = FindProperty("_AnisotropyMap");
-            Properties.Anisotropy = FindProperty("_Anisotropy");
-            Properties.KKColor = FindProperty("_KKColor");
-            Properties.BSDFContribution = FindProperty("_BSDFContribution");
+            Properties.anisotropyMap = FindProperty("_AnisotropyMap");
+            Properties.anisotropy = FindProperty("_Anisotropy");
+            Properties.kkColor = FindProperty("_KKColor");
+            Properties.bsdfContribution = FindProperty("_BSDFContribution");
 
-            Properties.SpecularColorMap = FindProperty("_SpecularColorMap");
-            Properties.SpecularColor = FindProperty("_SpecularColor");
-            Properties.SpecularFeather = FindProperty("_ToonSpecularFeather");
-            Properties.SpecularStep = FindProperty("_ToonSpecularStep");
+            Properties.specularColorMap = FindProperty("_SpecularColorMap");
+            Properties.specularColor = FindProperty("_SpecularColor");
+            Properties.specularFeather = FindProperty("_ToonSpecularFeather");
+            Properties.specularStep = FindProperty("_ToonSpecularStep");
+
+            Properties.hairBlendingMap = FindProperty("_HairBlendingMap");
 
             Properties.emissiveColorLDR = FindProperty(EMISSIVE_COLOR_LDR);
             Properties.emissiveColorMap = FindProperty(EMISSIVE_COLOR_MAP);
@@ -106,46 +112,55 @@ namespace Misaki.HdrpToon.Editor
 
         protected override void DrawContent()
         {
-            editor.KeywordTexturePropertySingleLine(Styles.NormalMapText, Properties.NormalMap, Properties.NormalMapScale);
+            editor.KeywordTexturePropertySingleLine(Styles.normalMapText, Properties.normalMap, Properties.normalMapScale);
 
             if (materials.All(mat => mat.GetPBRMode() != PBRMode.Off))
             {
-                if (editor.KeywordTexturePropertySingleLine(Styles.MaskMapText, Properties.MaskMap))
+                if (editor.KeywordTexturePropertySingleLine(Styles.maskMapText, Properties.maskMap))
                 {
-                    editor.MinMaxShaderProperty(Properties.MetallicRemapMin, Properties.MetallicRemapMax, 0, 1, Styles.MetallicRemap);
-                    editor.MinMaxShaderProperty(Properties.AORemapMin, Properties.AORemapMax, 0, 1, Styles.AORemap);
-                    editor.MinMaxShaderProperty(Properties.SmoothnessRemapMin, Properties.SmoothnessRemapMax, 0, 1, Styles.SmoothnessRemapText);
+                    editor.MinMaxShaderProperty(Properties.metallicRemapMin, Properties.metallicRemapMax, 0, 1, Styles.metallicRemap);
+                    editor.MinMaxShaderProperty(Properties.aoRemapMin, Properties.aoRemapMax, 0, 1, Styles.aoRemap);
+                    editor.MinMaxShaderProperty(Properties.smoothnessRemapMin, Properties.smoothnessRemapMax, 0, 1, Styles.smoothnessRemapText);
                 }
                 else
                 {
-                    if (materials.All(mat => mat.GetPBRMode() != PBRMode.KKHair))
+                    if (materials.All(mat =>
                     {
-                        editor.ShaderProperty(Properties.Metallic, Styles.MetallicText);
+                        var pbrMode = mat.GetPBRMode();
+                        return pbrMode != PBRMode.KKHair && pbrMode != PBRMode.Toon;
+                    }))
+                    {
+                        editor.ShaderProperty(Properties.metallic, Styles.metallicText);
                     }
 
-                    editor.ShaderProperty(Properties.Smoothness, Styles.SmoothnessText);
+                    editor.ShaderProperty(Properties.smoothness, Styles.smoothnessText);
                 }
             }
 
             if (materials.All(mat => mat.GetPBRMode() == PBRMode.Anisotropy || mat.GetPBRMode() == PBRMode.KKHair))
             {
                 EditorGUILayout.Space();
-                editor.KeywordTexturePropertySingleLine(Styles.AnisotropyMapText, Properties.AnisotropyMap, Properties.Anisotropy);
+                editor.KeywordTexturePropertySingleLine(Styles.anisotropyMapText, Properties.anisotropyMap, Properties.anisotropy);
                 if (materials.All(mat => mat.GetPBRMode() == PBRMode.KKHair))
                 {
-                    editor.ShaderProperty(Properties.KKColor, Styles.KKColorText);
-                    editor.ShaderProperty(Properties.BSDFContribution, Styles.BSDFContributionText);
+                    editor.ShaderProperty(Properties.kkColor, Styles.kkColorText);
+                    editor.ShaderProperty(Properties.bsdfContribution, Styles.bsdfContributionText);
                 }
 
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField("Anisotropy Map only ST");
-                editor.TextureScaleOffsetProperty(Properties.AnisotropyMap);
+                editor.TextureScaleOffsetProperty(Properties.anisotropyMap);
             }
             else if (materials.All(mat => mat.GetPBRMode() == PBRMode.Toon))
             {
                 EditorGUILayout.Space();
-                editor.KeywordTexturePropertySingleLine(Styles.SpecularColorMapText, Properties.SpecularColorMap, Properties.SpecularColor);
-                editor.MinMaxShaderProperty(Properties.SpecularFeather, Properties.SpecularStep, 0, 1, Styles.SpecRemap);
+                editor.KeywordTexturePropertySingleLine(Styles.specularColorMapText, Properties.specularColorMap, Properties.specularColor);
+                editor.MinMaxShaderProperty(Properties.specularFeather, Properties.specularStep, 0, 1, Styles.specRemap);
+            }
+
+            if (materials.All(mat => mat.IsHairBlendingTarget()))
+            {
+                editor.TexturePropertySingleLine(Styles.hairBlenderMapText, Properties.hairBlendingMap);
             }
 
             EditorGUILayout.Space();

Editor/MeterialEditor/UIScopes/SurfaceOptionsScope.cs

@@ -63,7 +63,7 @@ namespace Misaki.HdrpToon.Editor
             editor.ShaderProperty(Properties.transparentMode, Styles.transparentModeText);
 
             editor.ShaderProperty(Properties.alphaClipEnable, Styles.alphaClipEnableText);
-            if (Properties.alphaClipEnable.floatValue == 1.0f)
+            if (Properties.alphaClipEnable.GetBooleanValue())
             {
                 EditorGUI.indentLevel++;
                 editor.ShaderProperty(Properties.alphaClip, Styles.alphaClipText);
@@ -90,7 +90,7 @@ namespace Misaki.HdrpToon.Editor
             {
                 foreach (var material in materials)
                 {
-                    material.SetShaderPassEnabled(UtsShaderPassName.HAIR_BLENDING_TARGET_PASS_NAME, Properties.hairBlendingTarget.floatValue == 1.0f);
+                    material.SetShaderPassEnabled(UtsShaderPassName.HAIR_BLENDING_TARGET_PASS_NAME, Properties.hairBlendingTarget.GetBooleanValue());
                 }
             }
 

Editor/MeterialEditor/UTSShaderGUI.cs

@@ -8,6 +8,12 @@ namespace Misaki.HdrpToon.Editor
     {
         private GUIStyle _headerStyle;
 
+        public override void ValidateMaterial(Material material)
+        {
+            material.SetShaderPassEnabled(UtsShaderPassName.HAIR_SHADOW_CASTER_PASS_NAME, (MaterialType)material.GetInteger("_Material_Type") == MaterialType.FrontHair);
+            material.SetShaderPassEnabled(UtsShaderPassName.HAIR_BLENDING_TARGET_PASS_NAME, material.GetInteger("_HairBlendingTarget") == 1);
+        }
+
         public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
         {
             if (!initialized)

README.md

@@ -41,7 +41,7 @@ The HDRP Toon Shader is designed to provide a high-quality toon shading effect f
 ## Example
 Here are some examples of the HDRP Toon Shader in action:
 
-![preview-01.png](https://s2.loli.net/2024/12/26/zHdfSXho4csURyx.png)
+![preview-01.png](https://i.postimg.cc/nV3fT2PR/Screenshot-2025-05-13-212926.png)
 
 ## Contributing
 

Runtime/Constants/UtsShaderPropertyName.cs

@@ -7,6 +7,7 @@ namespace Misaki.HdrpToon
             public const string SHADING_MODE = "_Shading_Mode";
             public const string PBR_MODE = "_PBR_Mode";
             public const string SURFACE_FEATURE = "_SurfaceFeatures";
+            public const string MATERIAL_TYPE = "_Material_Type";
         }
 
         public static class SurfaceInputs
@@ -72,6 +73,8 @@ namespace Misaki.HdrpToon
 
         public static class Advance
         {
+            public const string MINIMAL_DIFFUSE_CONTRIBUTION = "_Minimal_Diffuse_Contribution";
+
             public const string LIGHT_INTENSITY_MULTIPLIER = "_LightIntensityMultiplier";
             public const string CLAMP_LIGHT_COLOR = "_ClampLightColor";
 

Runtime/Shaders/HDRPToon.shader

@@ -4,8 +4,6 @@ Shader "HDRP/Toon"
     {
         //TODO: Use custom rendering data.
         [ToggleUI]  _UseShadowThreshold("_UseShadowThreshold", Float) = 0.0
-        [ToggleUI]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
-        _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
         _AlphaCutoffShadow("_AlphaCutoffShadow", Range(0.0, 1.0)) = 0.5
         _AlphaCutoffPrepass("_AlphaCutoffPrepass", Range(0.0, 1.0)) = 0.5
         _AlphaCutoffPostpass("_AlphaCutoffPostpass", Range(0.0, 1.0)) = 0.5
@@ -49,7 +47,6 @@ Shader "HDRP/Toon"
         [HideInInspector] _AlphaDstBlend("__alphaDst", Float) = 0.0
         [HideInInspector][ToggleUI] _ZWrite("__zw", Float) = 1.0
         [HideInInspector][ToggleUI] _TransparentZWrite("_TransparentZWrite", Float) = 0.0
-        //[Enum(Off, 0, Front, 1, Back, 2)] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _CullModeForward("__cullmodeForward", Float) = 2.0 // This mode is dedicated to Forward to correctly handle backface then front face rendering thin transparent
         [HideInInspector] _TransparentCullMode("_TransparentCullMode", Int) = 2 // Back culling by default
         [HideInInspector] _ZTestDepthEqualForOpaque("_ZTestDepthEqualForOpaque", Int) = 4 // Less equal
@@ -72,7 +69,6 @@ Shader "HDRP/Toon"
         _Color("Color", Color) = (1,1,1,1)
         _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
-
         // -----------------------------------------------------------------------
         // -----------------------------------------------------------------------
         // -----------------------------------------------------------------------
@@ -86,7 +82,7 @@ Shader "HDRP/Toon"
 
         // Surface Options
         [Popup] _TransparentEnabled("Transparent Mode", Integer) = 0
-        [ToggleUI]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
+        [Popup(_ALPHATEST_ON)]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
         [Enum(Off, 0, Front, 1, Back, 2)] _CullMode("Cull Mode", Integer) = 2
         [KeywordEnum(Standard, SDF)] _Shading_Mode("Shading mode", Integer) = 0
@@ -123,6 +119,8 @@ Shader "HDRP/Toon"
         _SDFShadowSmoothLevel("SDFShadowSmoothLevel", Range(0.0, 0.1)) = 0.02
         _SDFHighlightStrength("SDFHighlightStrength", Range(0.0, 1.0)) = 0.75
 
+        _HairBlendingFactor("HairBlendingFactor", Range(0.0, 1.0)) = 0.5
+
         // Shadow
         [Popup] _Receive_Light_Shadow("Receive Light Shadow", Integer) = 0
         [Popup] _Receive_Screen_Space_Shadow("Receive Screen Space Shadow", Integer) = 0
@@ -187,6 +185,10 @@ Shader "HDRP/Toon"
         _IndirectSpecularMatCapMap("IndirectSpecularMatCapMap", 2D) = "black" {}
         _IndirectSpecularMatCapLod("IndirectSpecularMatCapMapLOD", Range(-5, 5)) = 0.0
 
+        _IndirectDiffuseRampMap("_IndirectDiffuseRampMap", 2DArray) = "black" {}
+        _IndirectDiffuseRampIndex("IndirectDiffuseRampIndex", Integer) = 0
+        _IndirectDiffuseRampPosition("IndirectDiffuseRampPosition", Range(0, 1)) = 0.5
+
         _IndirectSpecularIntensity("Indirect Specular Intensity", Range(0, 5)) = 1.0
         _SSRWeight("SSR Weight", Range(0.0, 1.0)) = 1.0
 
@@ -238,7 +240,24 @@ Shader "HDRP/Toon"
         // Advance
         _LightIntensityMultiplier("Light_Intensity_Multiplier" , Range(0, 1)) = 0.5
         [ToggleUI] _ClampLightColor("VRChat : SceneLights HiCut_Filter", Float) = 0
+        _Minimal_Diffuse_Contribution("Minimal_Diffuse_Contribution", Range(0, 1)) = 0.05
         [KeywordEnum(Single, Full, Custom)] _Light_Loop_Mode ("Light Loop Mode", Float) = 1
+
+
+        //TODO: Clear hdrp default properties
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0
+        [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
+        [ToggleUI] _LinkDetailsWithBase("LinkDetailsWithBase", Float) = 1.0
+
+        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5, Same as Base, 6)] _UVEmissive("UV Set for emissive", Float) = 0
+        [Enum(WorldSpace, 0, ObjectSpace, 1)] _ObjectSpaceUVMappingEmissive("Mapping space", Float) = 0.0
+        _TexWorldScaleEmissive("Scale to apply on world coordinate", Float) = 1.0
+        [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
+
+        [HideInInspector] _DiffusionProfile("Obsolete, kept for migration purpose", Int) = 0
+        [HideInInspector] _DiffusionProfileAsset("Diffusion Profile Asset", Vector) = (0, 0, 0, 0)
+        [HideInInspector] _DiffusionProfileHash("Diffusion Profile Hash", Float) = 0
     }
 
     HLSLINCLUDE
@@ -249,15 +268,7 @@ Shader "HDRP/Toon"
     //-------------------------------------------------------------------------------------
     // Variant
     //-------------------------------------------------------------------------------------
-
-    #pragma shader_feature_local _ALPHATEST_ON
-    #pragma shader_feature_local _DEPTHOFFSET_ON
     #pragma shader_feature_local _DOUBLESIDED_ON
-    #pragma shader_feature_local _ _VERTEX_DISPLACEMENT _PIXEL_DISPLACEMENT
-    #pragma shader_feature_local _VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE
-    #pragma shader_feature_local _DISPLACEMENT_LOCK_TILING_SCALE
-    #pragma shader_feature_local _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
-    #pragma shader_feature_local _TESSELLATION_PHONG
 
     #pragma shader_feature_local _NORMALMAP_TANGENT_SPACE
     #pragma shader_feature_local _ _REQUIRE_UV2 _REQUIRE_UV3
@@ -327,6 +338,7 @@ Shader "HDRP/Toon"
 
             HLSLPROGRAM
 
+            #pragma shader_feature_local _ALPHATEST_ON
             // Note: Require _ObjectId and _PassValue variables
 
             // We reuse depth prepass for the scene selection, allow to handle alpha correctly as well as tessellation and vertex animation
@@ -430,6 +442,7 @@ Shader "HDRP/Toon"
 
             HLSLPROGRAM
 
+            #pragma shader_feature_local _ALPHATEST_ON
             // Lightmap memo
             // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light,
             // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
@@ -462,6 +475,8 @@ Shader "HDRP/Toon"
 
             HLSLPROGRAM
 
+            #pragma shader_feature_local _ALPHATEST_ON
+
             #define SHADERPASS SHADERPASS_SHADOWS
             #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"
@@ -481,7 +496,7 @@ Shader "HDRP/Toon"
             Tags{ "LightMode" = "DepthForwardOnly" }
 
             Cull[_CullMode]
-
+            AlphaToMask [_AlphaCutoffEnable]
             // To be able to tag stencil with disableSSR information for forward
             Stencil
             {
@@ -495,6 +510,8 @@ Shader "HDRP/Toon"
 
             HLSLPROGRAM
 
+            #pragma shader_feature_local _ALPHATEST_ON
+
             // In deferred, depth only pass don't output anything.
             // In forward it output the normal buffer
             #pragma multi_compile _ WRITE_NORMAL_BUFFER
@@ -534,6 +551,7 @@ Shader "HDRP/Toon"
             }
 
             Cull[_CullMode]
+            AlphaToMask [_AlphaCutoffEnable]
 
             ZWrite On
 
@@ -541,6 +559,9 @@ Shader "HDRP/Toon"
             #pragma multi_compile _ WRITE_NORMAL_BUFFER
             #pragma multi_compile _ WRITE_MSAA_DEPTH
 
+            #pragma shader_feature_local _ALPHATEST_ON
+
+
             #define SHADERPASS SHADERPASS_MOTION_VECTORS
             #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"
@@ -603,6 +624,9 @@ Shader "HDRP/Toon"
 
             HLSLPROGRAM
 
+            #pragma shader_feature_local _ALPHATEST_ON
+
+
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
             #define CUTOFF_TRANSPARENT_DEPTH_PREPASS
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
@@ -630,6 +654,9 @@ Shader "HDRP/Toon"
             ZTest [_ZTestTransparent]
 
             HLSLPROGRAM
+
+            #pragma shader_feature_local _ALPHATEST_ON
+
             #pragma multi_compile _ DEBUG_DISPLAY
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED
@@ -682,7 +709,7 @@ Shader "HDRP/Toon"
             ZWrite [_ZWriteMode]
             ZTest [_ZTestMode]
             Cull [_CullMode]
-            Blend SrcAlpha OneMinusSrcAlpha
+            Blend [_SrcBlend] [_DstBlend], [_AlphaSrcBlend] [_AlphaDstBlend]
             Stencil {
 
                 Ref[_StencilNo]
@@ -694,7 +721,6 @@ Shader "HDRP/Toon"
             }
 
             HLSLPROGRAM
-            //#pragma multi_compile _ UTS_DEBUG_SHADOWMAP_BINALIZATION
             #pragma multi_compile _ DEBUG_DISPLAY
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED
@@ -716,15 +742,7 @@ Shader "HDRP/Toon"
             #if !defined(_SURFACE_TYPE_TRANSPARENT) && !defined(DEBUG_DISPLAY)
                 #define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
             #endif
-            // used in ShadingGradeMap
-            #pragma shader_feature _IS_TRANSCLIPPING_OFF _IS_TRANSCLIPPING_ON
-            #pragma shader_feature _IS_ANGELRING_OFF _IS_ANGELRING_ON
-            // used in Shadow calculation 
-            #pragma shader_feature _ UTS_USE_RAYTRACING_SHADOW
-            // used in DoubleShadeWithFeather
-            #pragma shader_feature _IS_CLIPPING_OFF _IS_CLIPPING_MODE _IS_CLIPPING_TRANSMODE
-            // controlling mask rendering
-            #pragma shader_feature _ _IS_CLIPPING_MATTE
+
             #pragma shader_feature _EMISSIVE_SIMPLE _EMISSIVE_ANIMATION
 
             #pragma shader_feature ENABLE_UTS_HAIR_SHAOW
@@ -759,6 +777,9 @@ Shader "HDRP/Toon"
 
             #pragma shader_feature_local_fragment _OUTLINECOLORMAP
 
+            #pragma shader_feature_local _ALPHATEST_ON
+
+
             #define PUNCTUAL_SHADOW_MEDIUM
             #define DIRECTIONAL_SHADOW_MEDIUM
             #define AREA_SHADOW_MEDIUM
@@ -819,6 +840,9 @@ Shader "HDRP/Toon"
             ColorMask 0
 
             HLSLPROGRAM
+
+            #pragma shader_feature_local _ALPHATEST_ON
+
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
             #define CUTOFF_TRANSPARENT_DEPTH_POSTPASS
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
@@ -870,7 +894,6 @@ Shader "HDRP/Toon"
 
             HLSLPROGRAM
 
-
             #define AREA_SHADOW_LOW
             #define SHADERPASS SHADERPASS_FORWARD
             #define SHADOW_LOW
@@ -884,13 +907,6 @@ Shader "HDRP/Toon"
                 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
             #endif
 
-            // The light loop (or lighting architecture) is in charge to:
-            // - Define light list
-            // - Define the light loop
-            // - Setup the constant/data
-            // - Do the reflection hierarchy
-            // - Provide sampling function for shadowmap, ies, cookie and reflection (depends on the specific use with the light loops like index array or atlas or single and texture format (cubemap/latlong))
-
             #define HAS_LIGHTLOOP
 
             #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl"
@@ -901,8 +917,6 @@ Shader "HDRP/Toon"
             #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"
 
-
-
             #include "Packages/com.misaki.hdrp-toon/Runtime/Shaders/Includes/Common/UtsHead.hlsl"
             #include "Packages/com.misaki.hdrp-toon/Runtime/Shaders/Includes/ShaderPass/HDRPToonOutline.hlsl"
 
@@ -928,6 +942,9 @@ Shader "HDRP/Toon"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_SHADOWS
+
+            #pragma shader_feature_local _ALPHATEST_ON
+
             #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/LitDepthPass.hlsl"

Runtime/Shaders/Includes/Common/UtsHead.hlsl

@@ -124,11 +124,11 @@ UTSSurfaceData GetUTSSurfaceData(FragInputs input, float3 V)
 
     float4 normalLocal = float4(0, 0, 1.0, 1.0);
 #if _NORMALMAP
-    if (_Use_SSSLut)
-    {
-        normalLocal = SAMPLE_TEXTURE2D_LOD(_NormalMap, sampler_NormalMap, TRANSFORM_TEX(input.texCoord0, _BaseColorMap), _SSSIntensity);
-    }
-    else
+    // if (_Use_SSSLut)
+    // {
+    //     normalLocal = SAMPLE_TEXTURE2D_LOD(_NormalMap, sampler_NormalMap, TRANSFORM_TEX(input.texCoord0, _BaseColorMap), _SSSIntensity);
+    // }
+    // else
     {
         normalLocal = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, TRANSFORM_TEX(input.texCoord0, _BaseColorMap));
         normalLocal.rgb = UnpackNormalScale(normalLocal, _NormalScale);
@@ -173,11 +173,13 @@ UTSSurfaceData GetUTSSurfaceData(FragInputs input, float3 V)
     smoothness *=_BSDFContribution;
 #endif
 
-#ifdef _PBR_Mode_TOON
+// TODO: Specular color is not handle correctly.
+#ifdef _PBR_MODE_TOON
+    metallic = 0.0;
+    specularColor = _SpecularColor;
 #ifdef _SPECULARCOLORMAP
-    specularColor = SAMPLE_TEXTURE2D(_SpecularColorMap, sampler_SpecularColorMap, TRANSFORM_TEX(input.texCoord0, _BaseColorMap)).rgb * _SpecularColor;
+    specularColor *= SAMPLE_TEXTURE2D(_SpecularColorMap, sampler_SpecularColorMap, TRANSFORM_TEX(input.texCoord0, _BaseColorMap)).rgb;
 #endif
-    specularColor = GetSpecularColor(output.baseColor, metallic);
 #endif
 
     output.metallic = metallic;
@@ -190,7 +192,8 @@ UTSSurfaceData GetUTSSurfaceData(FragInputs input, float3 V)
     output.geomNormalWS = input.tangentToWorld[2];
     output.tangentWS = Orthonormalize(input.tangentToWorld[0].rgb, normalWS);
 
-    output.subsurfaceColor = SAMPLE_TEXTURE2D(_SSSLutMap, s_linear_clamp_sampler, TRANSFORM_TEX(input.texCoord0, _BaseColorMap)) * _SSSIntensity;
+    // output.subsurfaceColor = SAMPLE_TEXTURE2D(_SSSLutMap, s_linear_clamp_sampler, TRANSFORM_TEX(input.texCoord0, _BaseColorMap)) * _SSSIntensity;
+    output.subsurfaceColor = 0.0;
 
     output.anisotropy = anisotropy;
 
@@ -203,12 +206,19 @@ UtsBSDFData ConvertUTSSurfaceDataToUTSBSDFData(UTSSurfaceData surfaceData)
 
     output.surfaceFeatures = surfaceData.surfaceFeatures;
 
-    output.diffuseColor = UtsComputeDiffuseColor(surfaceData.baseColor, surfaceData.metallic, 0.05);
-    output.firstShadingDiffuseColor = UtsComputeDiffuseColor(surfaceData.firstShadingColor, surfaceData.metallic, 0.05);
-    output.secondShadingDiffuseColor = UtsComputeDiffuseColor(surfaceData.secondShadingColor, surfaceData.metallic, 0.05);
+#if _PBR_MODE_TOON
+    float m = Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b);
+#else
+    float m = surfaceData.metallic;
+#endif
+    output.diffuseColor = UtsComputeDiffuseColor(surfaceData.baseColor, m, _Minimal_Diffuse_Contribution);
+    output.firstShadingDiffuseColor = UtsComputeDiffuseColor(surfaceData.firstShadingColor, m, _Minimal_Diffuse_Contribution);
+    output.secondShadingDiffuseColor = UtsComputeDiffuseColor(surfaceData.secondShadingColor, m, _Minimal_Diffuse_Contribution);
 
 #if _PBR_MODE_OFF
-    output.fresnel0 = surfaceData.baseColor;
+    output.fresnel0 = 0.22;
+#elif _PBR_MODE_TOON
+    output.fresnel0 = surfaceData.specularColor;
 #else
     output.fresnel0 = ComputeFresnel0(surfaceData.baseColor, surfaceData.metallic, 0.22);
 #endif

Runtime/Shaders/Includes/Deprecated/ShadingOtherLight.hlsl

@@ -11,13 +11,6 @@ void UTS_OtherLights(LightLoopContext lightLoopContext, FragInputs input, UTSLig
 
     // We dont have to calculate lighting here if we are using sdf shadow
 #ifndef _SDFShadow
-#ifdef _IS_CLIPPING_MATTE
-    if (_ClippingMatteMode != 0)
-    {
-
-        return float3(0.0f, 0.0f, 0.0f);
-    }
-#endif // _IS_CLIPPING_MATTE
 
     uint2 tileIndex = uint2(input.positionSS.xy) / GetTileSize();
     // input.positionSS is SV_Position

Runtime/Shaders/Includes/Lighting/UtsLightEvaluation.hlsl

@@ -194,9 +194,10 @@ IndirectLighting UtsEvaluateBSDF_MatCapSpecular(float3 positionWS, UtsBSDFData b
     return lighting;
 }
 
-void UtsEvaluateBSDF_Ramp(PositionInputs posInput, UtsBSDFData bsdfData, float3 L, inout BuiltinData builtinData)
+void UtsEvaluateBSDF_Ramp(PositionInputs posInput, UtsBSDFData bsdfData, inout BuiltinData builtinData)
 {
-    // TODO
+    float3 lighting = SAMPLE_TEXTURE2D_ARRAY(_IndirectDiffuseRampMap, s_trilinear_clamp_sampler, float2(_IndirectDiffuseRampPosition, 0.0), _IndirectDiffuseRampIndex).rgb;
+    builtinData.bakeDiffuseLighting = lighting * GetInverseCurrentExposureMultiplier();
 }
 
 IndirectLighting UtsEvaluateBSDF_Env(LightLoopContext lightLoopContext, PositionInputs posInput, PreLightData preLightData, EnvLightData lightData, UtsBSDFData bsdfData, int influenceShapeType, int GPUImageBasedLightingType, inout float hierarchyWeight)

Runtime/Shaders/Includes/Lighting/UtsLightLoop.hlsl

@@ -317,7 +317,6 @@ void UtsLightLoop(FragInputs fragInputs, PositionInputs posInput, UtsBSDFData bs
                             AccumulateIndirectLighting(lighting, aggregateLighting);
                         }
                     }
-                    
                 }
             }
         #elif _INDIRECT_SPECULAR_MODE_MATCAP

Runtime/Shaders/Includes/Lighting/UtsMaterialEvaluation.hlsl

@@ -63,11 +63,9 @@ float3 ComputeSpecularTerm(UtsBSDFData bsdfData, PreLightData preLightData, floa
     float specularExponent = RoughnessToBlinnPhongSpecularExponent(PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness));
     DV = pow(NdotH, 5.0 * specularExponent);
     DV = StepFeatherToon(DV, _ToonSpecularStep, _ToonSpecularFeather);
-    //specTerm = pow(NdotH, 5.0 * specularExponent);
-    //specTerm = StepFeatherToon(specTerm, _ToonSpecularStep, _ToonSpecularFeather);
-    //return specTerm * ColorSpaceDielectricSpec.rgb * clampedNdotL;
 #endif
 
+    // We use specularFGD here to approximate F.
     specTerm = DV * preLightData.specularFGD * clampedNdotL;
     return specTerm;
 #endif
@@ -139,12 +137,12 @@ DirectLighting UtsShadeSurface(PositionInputs posInput, UtsBSDFData bsdfData, Pr
         float NdotL = dot(bsdfData.normalWS, L);
         float halfLambert = 0.5 * NdotL + 0.5;
     
-        float3 rampColor = SAMPLE_TEXTURE2D_ARRAY_LOD(_ShadingRampMap, s_linear_clamp_sampler, float2(halfLambert * shadow.x, rampMask), _ShadingIndex, 0.0).rgb;
+        float3 rampColor = SAMPLE_TEXTURE2D_ARRAY(_ShadingRampMap, s_linear_clamp_sampler, float2(halfLambert * shadow.x, rampMask), _ShadingIndex).rgb;
         
         diffuseTerm = bsdfData.diffuseColor * rampColor;
         specularTerm *= saturate(NdotL) * sharpShadow;
         #elif _SHADING_MODE_SDF
-        float3 rampColor = SAMPLE_TEXTURE2D_ARRAY_LOD(_ShadingRampMap, s_linear_clamp_sampler, float2(sdfShadowMask * sharpShadow.x, rampMask), _ShadingIndex, 0.0).rgb;
+        float3 rampColor = SAMPLE_TEXTURE2D_ARRAY(_ShadingRampMap, s_linear_clamp_sampler, float2(sdfShadowMask * sharpShadow.x, rampMask), _ShadingIndex).rgb;
         
         diffuseTerm = bsdfData.diffuseColor * rampColor;
         specularTerm = (specularTerm + sdfHighlight) * sdfShadowMask * sharpShadow;

Runtime/Shaders/Includes/Lighting/UtsShadowEvaluation.hlsl

@@ -44,9 +44,10 @@ float GetHairShadow(PositionInputs posInput, float3 L)
         float cameraDirFactor = 1 - smoothstep(0.1, 0.9, cameraDirOS.y);
         shadowLength.y *= cameraDirFactor;
 
+        // TODO: sample point is still shifting when fov change.
         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.
 
-        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.
+        float2 scaledUVs = samplingPoint * _RTHandleScale.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 hairShadow = SAMPLE_TEXTURE2D_SHADOW(_HairShadowTex, s_linear_clamp_compare_sampler, float3(scaledUVs, posInput.deviceDepth + _HairShadowDepthBias)).r;
         shadow = lerp(1.0 - hairShadowOpacity, 1.0, hairShadow);
     }

Runtime/Shaders/Includes/Properties/UtsHdrpProperties.hlsl

@@ -62,11 +62,11 @@ float _ToonIgnoreExposureMultiplier;
 
 float _Outline_MaxWidth;
 
-float4 _HairShadowRTHandleScale;
-float4 _HairBlendingRTHandleScale;
-
 float _HairShadowDistance;
 float _HairShadowDistanceScaleFactor;
 float _HairShadowDepthBias;
 float _HairShadowFadeInDistance;
 float _HairShadowFadeOutDistance;
+
+// float2 _HairShadowRTHandleScale;
+// float2 _HairBlendingRTHandleScale;

Runtime/Shaders/Includes/Properties/UtsTextures.hlsl

@@ -42,6 +42,8 @@ TEXTURE2D_X(_HairBlendingTex);
 TEXTURE2D(_IndirectDiffuseMatCapMap);
 TEXTURE2D(_IndirectSpecularMatCapMap);
 
+TEXTURE2D_ARRAY(_IndirectDiffuseRampMap);
+
 TEXTURE2D(_ClippingMask);
 
 TEXTURE2D(_AngelRingColorMap);

Runtime/Shaders/Includes/Properties/UtsUnityPerMaterial.hlsl

@@ -1,5 +1,7 @@
 // Surface Option
 float _SurfaceFeatures;
+half _AlphaCutoffEnable;
+float _AlphaCutoff;
 
 // Shading Color
 float4 _BaseColor;
@@ -7,8 +9,8 @@ float4 _BaseColorMap_ST;
 float4 _BaseColorMap_TexelSize;
 float4 _BaseColorMap_MipInfo;
 
-float _ShadingIndex;
-half _ShadingRampMask;
+int _ShadingIndex;
+float _ShadingRampMask;
 
 float4 _1stShadeColor;
 float4 _2ndShadeColor;
@@ -58,8 +60,8 @@ float _ToonSpecularFeather;
 float _BSDFContribution;
 float _EnergyConservingSpecularColor;
 
-float _SSSIntensity;
-int _Use_SSSLut;
+// float _SSSIntensity;
+// int _Use_SSSLut;
 
 float3 _EmissiveColor;
 half _AlbedoAffectEmissive;
@@ -70,6 +72,9 @@ float _ObjectSpaceUVMappingEmissive;
 // Ambient
 float _IndirectDiffuseMatCapLod;
 
+int _IndirectDiffuseRampIndex;
+float _IndirectDiffuseRampPosition;
+
 float _IndirectDiffuseIntensity;
 float _SSAOWeight;
 float _SSGIWeight;
@@ -114,15 +119,17 @@ float _HairBlendingFactor;
 // Advance
 half _ClampLightColor;
 float _LightIntensityMultiplier;
+float _Minimal_Diffuse_Contribution;
 
 // Light Loop
 float3 _ObjectCenterPositionWS;
 
-
 // NOTE: Not sure what these are for
 // float  _FirstShadeOverridden;
 // float  _SecondShadeOverridden;
 
+float _UseShadowThreshold;
+float _AlphaCutoffShadow;
 float _ComposerMaskMode;
 
 #if defined(_UTS_TOON_EV_PER_MODEL)

Runtime/Shaders/Includes/ShaderPass/HDRPToonHairBlending.hlsl

@@ -63,7 +63,7 @@ void Frag(PackedVaryingsToPS packedInput,
 #ifdef _DEPTHOFFSET_ON
             , out float outputDepth : SV_Depth
 #endif
-            )
+)
 {
     UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(packedInput);
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
@@ -73,7 +73,6 @@ void Frag(PackedVaryingsToPS packedInput,
 
     // 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(
@@ -83,8 +82,8 @@ void Frag(PackedVaryingsToPS packedInput,
     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, _BaseColorMap));
-    outColor = float4(_BlendingTex_var.rgb * ambientSkyColor, _BlendingTex_var.a);
+    float4 blendingTex = SAMPLE_TEXTURE2D(_HairBlendingMap, sampler_HairBlendingMap, TRANSFORM_TEX(Set_UV0, _BaseColorMap));
+    outColor = float4(blendingTex.rgb + ambientSkyColor, blendingTex.a);
 
 #ifdef _DEPTHOFFSET_ON
     outputDepth = posInput.deviceDepth;

Runtime/Shaders/Includes/ShaderPass/HDRPToonOutline.hlsl

@@ -82,12 +82,7 @@ void Frag(PackedVaryingsToPS packedInput,
         discard;
     }
 #endif
-#ifdef _IS_CLIPPING_MATTE
-    if (_ClippingMatteMode != 0)
-    {
-        discard;
-    }
-#endif // _IS_CLIPPING_MATTE
+
 #if defined(UTS_DEBUG_SHADOWMAP_NO_OUTLINE)
     discard;
 #endif

Runtime/Shaders/Includes/ShaderPass/UtsShaderPassForward.hlsl

@@ -146,8 +146,6 @@ void Frag(PackedVaryingsToPS packedInput,
     // Initialize the contactShadow and contactShadowFade fields
     InitContactShadow(posInput, context);
     
-    float channelAlpha = 0.0f;
-
     LightLoopOutput lightLoopOutput;
     ZERO_INITIALIZE(LightLoopOutput, lightLoopOutput);
     
@@ -155,22 +153,21 @@ void Frag(PackedVaryingsToPS packedInput,
     
     float3 finalColor = lightLoopOutput.diffuseLighting + lightLoopOutput.specularLighting;
 
-#ifdef _IS_TRANSCLIPPING_OFF
     
-    outColor = float4(finalColor, 1 * ApplyChannelAlpha(channelAlpha));
-
-#elif _IS_TRANSCLIPPING_ON
-    
-    float Set_Opacity = saturate((inverseClipping + _Tweak_transparency));
-    
-    outColor = EvaluateAtmosphericScattering(posInput, V, float4(finalColor, 1));
-    outColor = float4(outColor.rgb, Set_Opacity * ApplyChannelAlpha(channelAlpha));
-#endif
+// #if _SURFACE_TYPE_TRANSPARENT
+//     float alpha = channelAlpha;
+//     outColor = EvaluateAtmosphericScattering(posInput, V, float4(finalColor, 1));
+// #else
+//     float alpha = lerp(1.0, channelAlpha, _AlphaCutoffEnable);
+// #endif
+//
+//     alpha = lerp(alpha, step(_AlphaCutoff, alpha), _AlphaCutoffEnable);
+    outColor = float4(finalColor, 1.0);
 
 #if _MATERIAL_TYPE_FRONTHAIR && ENABLE_UTS_HAIR_BLENDING
-    float2 screenUV = posInput.positionNDC * _HairBlendingRTHandleScale.xy;
-    float4 hairBlendingMap = LOAD_TEXTURE2D_X(_HairBlendingTex, screenUV);
-    outColor.rgb = lerp(outColor.rgb, hairBlendingMap.rgb, hairBlendingMap.a * _HairBlendingFactor);
+    float2 screenUV = posInput.positionSS; // * _HairBlendingRTHandleScale.xy; // Why we don't need to scale? Does unity handle it internally?
+    float4 hairBlendingTex = LOAD_TEXTURE2D_X(_HairBlendingTex, screenUV);
+    outColor.rgb = lerp(outColor.rgb, hairBlendingTex.rgb, hairBlendingTex.a * _HairBlendingFactor);
 #endif
 
 #if UTS_DEBUG_SHADOWMAP || UTS_DEBUG_SELFSHADOW

Runtime/UTS Renderer/UTSPass.cs

@@ -21,15 +21,12 @@ 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 _HAIR_SHADOW_RT_PROP_NAME = "_HairShadowTex";
         private const string _HAIR_BLENDING_PROP_NAME = "_HairBlendingTex";
 
@@ -43,7 +40,9 @@ namespace Misaki.HdrpToon
         private RTHandle _hairShadowRTHandle;
         private bool _needReallocateHairShadow;
 
+        // TODO: Possible to avoid another RTHandle for depth?
         private RTHandle _hairBlendingRTHandle;
+        private RTHandle _hairBlendingDepthRTHandle;
         private bool _needReallocateHairBlending;
 
         private bool _enableHairShadow;
@@ -142,15 +141,16 @@ namespace Misaki.HdrpToon
             }
 #endif
 
-            var scale = _hairShadowQuality switch
+            // Use R8 or R16 directly?
+            var format = _hairShadowQuality switch
             {
-                BufferQuality.Low => new Vector2(0.5f, 0.5f),
-                BufferQuality.High => Vector2.one,
-                _ => Vector2.zero
+                BufferQuality.Low => GraphicsFormat.D16_UNorm,
+                BufferQuality.High => GraphicsFormat.D32_SFloat,
+                _ => GraphicsFormat.R16G16B16A16_SFloat
             };
 
             _hairShadowRTHandle?.Release();
-            _hairShadowRTHandle = RTHandles.Alloc(scale, useDynamicScale: true, format: GraphicsFormat.D16_UNorm, isShadowMap: true, name: _HAIR_SHADOW_RT_PROP_NAME);
+            _hairShadowRTHandle = RTHandles.Alloc(Vector2.one, useDynamicScale: true, format: format, isShadowMap: true, name: _HAIR_SHADOW_RT_PROP_NAME);
             Shader.SetGlobalTexture(_HAIR_SHADOW_RT_PROP_NAME, _hairShadowRTHandle);
 
             _needReallocateHairShadow = false;
@@ -179,6 +179,13 @@ namespace Misaki.HdrpToon
 
             _hairBlendingRTHandle?.Release();
             _hairBlendingRTHandle = RTHandles.Alloc(Vector2.one, useDynamicScale: true, dimension: TextureXR.dimension, colorFormat: format, name: _HAIR_BLENDING_PROP_NAME);
+
+            if (_hairBlendingDepthRTHandle == null || _hairBlendingDepthRTHandle.rt == null || !_hairBlendingDepthRTHandle.rt.IsCreated())
+            {
+                _hairBlendingDepthRTHandle?.Release();
+                _hairBlendingDepthRTHandle = RTHandles.Alloc(Vector2.one, useDynamicScale: true, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.D16_UNorm, name: _HAIR_BLENDING_PROP_NAME + "_depth");
+            }
+
             Shader.SetGlobalTexture(_HAIR_BLENDING_PROP_NAME, _hairBlendingRTHandle);
 
             _needReallocateHairBlending = false;
@@ -274,7 +281,6 @@ namespace Misaki.HdrpToon
 
                 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);
@@ -298,7 +304,7 @@ namespace Misaki.HdrpToon
 
             using (new ProfilingScope(ctx.cmd, _hairBlendingProfilingSampler))
             {
-                CoreUtils.SetRenderTarget(ctx.cmd, _hairBlendingRTHandle, ctx.cameraDepthBuffer, ClearFlag.Color);
+                CoreUtils.SetRenderTarget(ctx.cmd, _hairBlendingRTHandle, _hairBlendingDepthRTHandle, ClearFlag.Color | ClearFlag.Depth);
 
                 var result = new RendererListDesc(UtsShaderPassName.hairBlendingTargetPassId, ctx.cullingResults, ctx.hdCamera.camera)
                 {
@@ -308,7 +314,6 @@ namespace Misaki.HdrpToon
                 };
 
                 CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, ctx.renderContext.CreateRendererList(result));
-                Shader.SetGlobalVector(_HAIR_BLENDING_RTHANDLE_SCALE_PROP_NAME, _hairBlendingRTHandle.rtHandleProperties.rtHandleScale);
             }
         }
 
@@ -326,6 +331,7 @@ namespace Misaki.HdrpToon
             _exposureArray = null;
             _hairShadowRTHandle?.Release();
             _hairBlendingRTHandle?.Release();
+            _hairBlendingDepthRTHandle?.Release();
         }
     }
 }