Merge pull request #1847 from Unity-Technologies/Add-cloth-material-anis

Finishing a first version of the implementation of the Fabric Shader

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/BSDF.hlsl

 }
 
 //-----------------------------------------------------------------------------
-// Cloth
+// Fabric
 //-----------------------------------------------------------------------------
 
 // Ref: https://knarkowicz.wordpress.com/2018/01/04/cloth-shading/
     return 1.0 / (4.0 * (NdotL + NdotV - NdotL * NdotV));
 }
 
-// A diffuse term use with cloth done by tech artist - empirical
-real ClothLambertNoPI(real roughness)
+// A diffuse term use with fabric done by tech artist - empirical
+real FabricLambertNoPI(real roughness)
-real ClothLambert(real roughness)
+real FabricLambert(real roughness)
-    return INV_PI * ClothLambertNoPI(roughness);
+    return INV_PI * FabricLambertNoPI(roughness);
 }
 
 

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/CommonMaterial.hlsl

 #define UNITY_COMMON_MATERIAL_INCLUDED
 
 //-----------------------------------------------------------------------------
+// Define constants
+//-----------------------------------------------------------------------------
+
+#define DEFAULT_SPECULAR_VALUE 0.04
+
+//-----------------------------------------------------------------------------
 // Helper functions for roughness
 //-----------------------------------------------------------------------------
 

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/ImageBasedLighting.hlsl

 #endif
 
 #if !defined SHADER_API_GLES
-real4 IntegrateCharlieAndClothLambertFGD(real3 V, real3 N, real roughness, uint sampleCount = 8192)
+real4 IntegrateCharlieAndFabricLambertFGD(real3 V, real3 N, real roughness, uint sampleCount = 8192)
 {
     real NdotV     = ClampNdotV(dot(N, V));
     real4 acc      = real4(0.0, 0.0, 0.0, 0.0);
             acc.y += weightOverPdf;
         }
 
-        // for cloth Lambert we still use a Cosine importance sampling
+        // for Fabric Lambert we still use a Cosine importance sampling
-            real clothLambert = ClothLambertNoPI(roughness);
-            acc.z += clothLambert * weightOverPdf;
+            real fabricLambert = FabricLambertNoPI(roughness);
+            acc.z += fabricLambert * weightOverPdf;
         }
     }
 
 }
 #else
 // Not supported due to lack of random library in GLES 2
-#define IntegrateCharlieAndClothLambertFGD ERROR_ON_UNSUPPORTED_FUNCTION(IntegrateCharlieAndClothLambertFGD)
+#define IntegrateCharlieAndFabricLambertFGD ERROR_ON_UNSUPPORTED_FUNCTION(IntegrateCharlieAndFabricLambertFGD)
 #endif
 
 uint GetIBLRuntimeFilterSampleCount(uint mipLevel)

com.unity.render-pipelines.high-definition/CHANGELOG.md

 ### Changed
 - Changed default reflection probe to be 256x256x6 and array size to be 64
 
+### Added
+- Added a new Fabric shader model that supports Silk and Cotton/Wool
+
 ## [3.2.0-preview]
 
 ### Added

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Lit/BaseLitUI.cs

             windShiverDirectionality = FindProperty(kWindShiverDirectionality, props, false);
 
             // Decal
-            supportDecals = FindProperty(kSupportDecals, props);
+            supportDecals = FindProperty(kSupportDecals, props, false);
 
             // specular AA
             enableGeometricSpecularAA = FindProperty(kEnableGeometricSpecularAA, props, false);
             EditorGUI.showMixedValue = false;
         }
 
-        protected abstract void UpdateDisplacement();
+        protected virtual void UpdateDisplacement() {}
 
         protected override void BaseMaterialPropertiesGUI()
         {
                 }
             }
 
-            m_MaterialEditor.ShaderProperty(supportDecals, StylesBaseLit.supportDecalsText);
+            if (supportDecals != null)
+            {
+                m_MaterialEditor.ShaderProperty(supportDecals, StylesBaseLit.supportDecalsText);
+            }            
 
             if (enableGeometricSpecularAA != null)
             {
         {
             SetupBaseUnlitKeywords(material);
 
-            if (material.HasProperty(kDoubleSidedEnable) && material.GetFloat(kDoubleSidedEnable) > 0.0f)
+            bool doubleSidedEnable = material.HasProperty(kDoubleSidedEnable) ? material.GetFloat(kDoubleSidedEnable) > 0.0f : false;
+            if (doubleSidedEnable)
             {
                 DoubleSidedNormalMode doubleSidedNormalMode = (DoubleSidedNormalMode)material.GetFloat(kDoubleSidedNormalMode);
                 switch (doubleSidedNormalMode)
             SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
 
             // Use negation so we don't create keyword by default
-            CoreUtils.SetKeyword(material, "_DISABLE_DECALS", material.GetFloat(kSupportDecals) == 0.0);
+            CoreUtils.SetKeyword(material, "_DISABLE_DECALS", material.HasProperty(kSupportDecals) && material.GetFloat(kSupportDecals) == 0.0);
 
             CoreUtils.SetKeyword(material, "_ENABLE_GEOMETRIC_SPECULAR_AA", material.HasProperty(kEnableGeometricSpecularAA) && material.GetFloat(kEnableGeometricSpecularAA) == 1.0);
         }

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Unlit/BaseUnlitUI.cs

         protected abstract void FindMaterialProperties(MaterialProperty[] props);
         protected abstract void SetupMaterialKeywordsAndPassInternal(Material material);
         protected abstract void MaterialPropertiesGUI(Material material);
-        protected abstract void MaterialPropertiesAdvanceGUI(Material material);
+        protected virtual void MaterialPropertiesAdvanceGUI(Material material) {}
-        protected abstract bool ShouldEmissionBeEnabled(Material material);
+        protected virtual bool ShouldEmissionBeEnabled(Material material) { return false; }
 
         protected virtual void FindBaseMaterialProperties(MaterialProperty[] props)
         {

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/HDAssetFactory.cs

                 newAsset.name = Path.GetFileName(pathName);
 
                 newAsset.Init();
-
+                
                 AssetDatabase.CreateAsset(newAsset, pathName);
                 ProjectWindowUtil.ShowCreatedAsset(newAsset);
             }

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/HDEditorUtils.cs

             { "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass },
             { "HDRenderPipeline/LitTessellation", LitGUI.SetupMaterialKeywordsAndPass },
             { "HDRenderPipeline/Unlit", UnlitGUI.SetupMaterialKeywordsAndPass },
+            { "HDRenderPipeline/Fabric",  FabricGUI.SetupMaterialKeywordsAndPass },
             { "HDRenderPipeline/Decal", DecalUI.SetupMaterialKeywordsAndPass }
         };
 

com.unity.render-pipelines.high-definition/HDRP/Editor/Upgraders/UpgradeMenuItem.cs

                         mat.shader.name == "HDRenderPipeline/LayeredLitTessellation" ||
                         mat.shader.name == "HDRenderPipeline/StackLit" ||
                         mat.shader.name == "HDRenderPipeline/Unlit" ||
+                        mat.shader.name == "HDRenderPipeline/Fabric" ||
                         mat.shader.name == "HDRenderPipeline/Decal"
                          )
                     {

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

 
 #define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE)) && (defined(_REFRACTION_SSRAY_PROXY) || defined(_REFRACTION_SSRAY_HIZ))
 
-#define DEFAULT_SPECULAR_VALUE 0.04
-
 // Enum for materialFeatureId (only use for encode/decode GBuffer)
 #define GBUFFER_LIT_STANDARD         0
 // we have not enough space (3bit) to store mat feature to have SSS and Transmission as bitmask, such why we have all variant

com.unity.render-pipelines.high-definition/HDRP/Material/Material.hlsl

 #include "Unlit/Unlit.hlsl"
 #elif defined(UNITY_MATERIAL_STACKLIT)
 #include "StackLit/StackLit.hlsl"
+#elif defined(UNITY_MATERIAL_FABRIC)
+#include "Fabric/Fabric.hlsl"
 #endif
 
 //-----------------------------------------------------------------------------

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.cs

         public enum FGDIndex
         {
             FGD_GGXAndDisneyDiffuse = 0,
-            FGD_CharlieAndClothLambert = 1,
+            FGD_CharlieAndFabricLambert = 1,
             Count = 2
         }
 
                         m_PreIntegratedFGD[(int)index].Create();
                         break;
 
-                    case FGDIndex.FGD_CharlieAndClothLambert:
-                        m_PreIntegratedFGDMaterial[(int)index] = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.preIntegratedFGD_CharlieClothLambert);
+                    case FGDIndex.FGD_CharlieAndFabricLambert:
+                        m_PreIntegratedFGDMaterial[(int)index] = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.preIntegratedFGD_CharlieFabricLambert);
-                        m_PreIntegratedFGD[(int)index].name = CoreUtils.GetRenderTargetAutoName(128, 128, 1, RenderTextureFormat.ARGB2101010, "preIntegratedFGD_CharlieClothLambert");
+                        m_PreIntegratedFGD[(int)index].name = CoreUtils.GetRenderTargetAutoName(128, 128, 1, RenderTextureFormat.ARGB2101010, "preIntegratedFGD_CharlieFabricLambert");
                         m_PreIntegratedFGD[(int)index].Create();
                         break;
 
                     Shader.SetGlobalTexture(HDShaderIDs._PreIntegratedFGD_GGXDisneyDiffuse, m_PreIntegratedFGD[(int)index]);
                     break;
 
-                case FGDIndex.FGD_CharlieAndClothLambert:
-                    Shader.SetGlobalTexture(HDShaderIDs._PreIntegratedFGD_CharlieAndCloth, m_PreIntegratedFGD[(int)index]);
+                case FGDIndex.FGD_CharlieAndFabricLambert:
+                    Shader.SetGlobalTexture(HDShaderIDs._PreIntegratedFGD_CharlieAndFabric, m_PreIntegratedFGD[(int)index]);
                     break;
 
                 default:

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.hlsl

     reflectivity = preFGD.y;
 }
 
-TEXTURE2D(_PreIntegratedFGD_CharlieAndCloth);
+TEXTURE2D(_PreIntegratedFGD_CharlieAndFabric);
-void GetPreIntegratedFGDCharlieAndClothLambert(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 CharlieSpecularFGD, out float clothLambertDiffuseFGD, out float reflectivity)
+void GetPreIntegratedFGDCharlieAndFabricLambert(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 CharlieSpecularFGD, out float fabricLambertDiffuseFGD, out float reflectivity)
-    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD_CharlieAndCloth, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
+    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD_CharlieAndFabric, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
-    // z = ClothLambert
-    clothLambertDiffuseFGD = preFGD.z;
+    // z = FabricLambert
+    fabricLambertDiffuseFGD = preFGD.z;
 
     reflectivity = preFGD.y;
 }

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/preIntegratedFGD_CharlieFabricLambert.shader

-Shader "Hidden/HDRenderPipeline/preIntegratedFGD_CharlieClothLambert"
+Shader "Hidden/HDRenderPipeline/preIntegratedFGD_CharlieFabricLambert"
 {
     SubShader
     {
                 float3 N                    = float3(0.0, 0.0, 1.0);
 
                 // Pre integrate GGX with smithJoint visibility as well as DisneyDiffuse
-                float4 preFGD = IntegrateCharlieAndClothLambertFGD(V, N, PerceptualRoughnessToRoughness(perceptualRoughness));
+                float4 preFGD = IntegrateCharlieAndFabricLambertFGD(V, N, PerceptualRoughnessToRoughness(perceptualRoughness));
 
                 return float4(preFGD.xyz, 1.0);
             }

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDStringConstants.cs

 
         // Preintegrated texture name
         public static readonly int _PreIntegratedFGD_GGXDisneyDiffuse = Shader.PropertyToID("_PreIntegratedFGD_GGXDisneyDiffuse");
-        public static readonly int _PreIntegratedFGD_CharlieAndCloth = Shader.PropertyToID("_PreIntegratedFGD_CharlieAndCloth");
+        public static readonly int _PreIntegratedFGD_CharlieAndFabric = Shader.PropertyToID("_PreIntegratedFGD_CharlieAndFabric");
     }
 }

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 0}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  version: 1
+  m_Version: 2
   defaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17, type: 2}
   defaultMirrorMaterial: {fileID: 2100000, guid: 6b17274157b33bc45b6a40e7d4ff51fe, type: 2}
   defaultDecalMaterial: {fileID: 2100000, guid: 500e733574922d04ea961553b1b26a63, type: 2}
   skyboxCubemap: {fileID: 103, guid: 0000000000000000f000000000000000, type: 0}
   gradientSky: {fileID: 4800000, guid: 2b5d4f1b26f03dc4a873b093e0c4adb1, type: 3}
   preIntegratedFGD_GGXDisneyDiffuse: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad, type: 3}
-  preIntegratedFGD_CharlieClothLambert: {fileID: 4800000, guid: 3b3bf235775cf8b4baae7f3306787ab0, type: 3}
+  preIntegratedFGD_CharlieFabricLambert: {fileID: 4800000, guid: 3b3bf235775cf8b4baae7f3306787ab0, type: 3}
   encodeBC6HCS: {fileID: 7200000, guid: aa922d239de60304f964e24488559eeb, type: 3}
   cubeToPanoShader: {fileID: 4800000, guid: 595434cc3b6405246b6cd3086d0b6f7d, type: 3}
   blitCubeTextureFace: {fileID: 4800000, guid: d850d0a2481878d4bbf17e5126b04163, type: 3}

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/RenderPipelineResources.cs

 
         // Material
         public Shader preIntegratedFGD_GGXDisneyDiffuse;
-        public Shader preIntegratedFGD_CharlieClothLambert;
+        public Shader preIntegratedFGD_CharlieFabricLambert;
 
         // Utilities / Core
         public ComputeShader encodeBC6HCS;
 
             // Material
             preIntegratedFGD_GGXDisneyDiffuse = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD_GGXDisneyDiffuse.shader");
-            preIntegratedFGD_CharlieClothLambert = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD_CharlieClothLambert.shader");
+            preIntegratedFGD_CharlieFabricLambert = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD_CharlieClothLambert.shader");
 
             // Utilities / Core
             encodeBC6HCS = Load<ComputeShader>(CorePath + "CoreResources/EncodeBC6H.compute");

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Fabric.meta

+fileFormatVersion: 2
+guid: 553571484746b1f4d8e16c85a45f34fe
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric.meta

+fileFormatVersion: 2
+guid: c42133a75ba128147bd0bb2259c8fcd8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Fabric/FabricUI.cs.meta

+fileFormatVersion: 2
+guid: 0dc76b11653f0bc44b592141f8763eb7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Fabric/FabricUI.cs

+using System;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    class FabricGUI : BaseLitGUI
+    {
+        protected static class Styles
+        {
+            // Fields
+            public static GUIContent fabricTypeText = new GUIContent("Fabric Type", "");
+            public static string InputsText = "Inputs";
+            public static string emissiveLabelText = "Emissive Inputs";
+
+            // Primary UV mapping
+            public static GUIContent UVBaseMappingText = new GUIContent("Base UV mapping", "");
+
+            // Base Color
+            public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)");
+
+            // Fuzz Tint
+            public static GUIContent fuzzTintText = new GUIContent("Fuzz Tint", "");
+
+            // Smoothness
+            public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
+            public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness scale factor");
+            public static GUIContent smoothnessRemappingText = new GUIContent("Smoothness Remapping", "Smoothness remapping");
+            
+            // AO
+            public static GUIContent aoRemappingText = new GUIContent("AmbientOcclusion Remapping", "AmbientOcclusion remapping");
+            
+            // Mask
+            public static GUIContent maskMapSText = new GUIContent("Mask Map - X, AO(G), D(B), S(A)", "Mask map");
+            public static GUIContent maskMapSpecularText = new GUIContent("Mask Map - AO(G), D(B), S(A)", "Mask map");
+
+            // Normal map
+            public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC7/BC5/DXT5(nm))");
+            // public static GUIContent bentNormalMapText = new GUIContent("Bent normal map", "Use only with indirect diffuse lighting (Lightmap/light-probe) - Cosine weighted Bent Normal Map (average un-occluded direction) (BC7/BC5/DXT5(nm))");
+
+            // Tangent map
+            public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC7/BC5/DXT5(nm))");
+           
+            // Anisotropy
+            public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor");
+            public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (R)", "Anisotropy");
+
+            // Detail map
+            public static string detailText = "Detail Inputs";
+            public static GUIContent UVDetailMappingText = new GUIContent("Detail UV mapping", "");
+            public static GUIContent detailMapNormalText = new GUIContent("Detail Map AO(R) Ny(G) S(B) Nx(A)", "Detail Map");
+            public static GUIContent detailMaskText = new GUIContent("Detail Mask (R)", "Detail Mask");
+            public static GUIContent detailFuzz1Text = new GUIContent("Fuzz Detail 1", "Fuzz Detail factor");
+            public static GUIContent detailAOScaleText = new GUIContent("Detail AO", "Detail AO Scale factor");
+            public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor");
+            public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor");
+            public static GUIContent linkDetailsWithBaseText = new GUIContent("Lock to Base Tiling/Offset", "Lock details Tiling/Offset to Base Tiling/Offset");
+
+            // Diffusion
+            public static GUIContent diffusionProfileText = new GUIContent("Diffusion profile", "A profile determines the shape of the SSS/transmission filter.");
+
+            // Transmission
+            public static GUIContent transmissionToggleText = new GUIContent("Transmission Enabled", "Enable/Disable the transmission");
+
+            // Subsurface scattering
+            public static GUIContent subsurfaceToggleText = new GUIContent("Subsurface Enabled", "Enable/Disable the subsurface");
+            public static GUIContent subsurfaceMaskText = new GUIContent("Subsurface mask", "Determines the strength of the subsurface scattering effect.");
+            public static GUIContent subsurfaceMaskMapText = new GUIContent("Subsurface mask map (R)", "Determines the strength of the subsurface scattering effect.");
+
+            // Thickness
+            public static GUIContent thicknessText = new GUIContent("Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
+            public static GUIContent thicknessMapText = new GUIContent("Thickness map (R)", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
+            public static GUIContent thicknessRemapText = new GUIContent("Thickness Remap", "Remaps values of the thickness map from [0, 1] to the specified range.");
+
+            // Emissive
+            public static GUIContent UVMappingEmissiveText = new GUIContent("Emissive UV mapping", "");
+            public static GUIContent emissiveText = new GUIContent("Emissive Map + Color", "Emissive Map + Color (linear RGB) in nits unit");
+            public static GUIContent albedoAffectEmissiveText = new GUIContent("Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.");
+
+            // Specular occlusion
+            // public static GUIContent enableSpecularOcclusionText = new GUIContent("Enable Specular Occlusion from Bent normal", "Require cosine weighted bent normal and cosine weighted ambient occlusion. Specular occlusion for reflection probe");
+            // public static GUIContent specularOcclusionWarning = new GUIContent("Require a cosine weighted bent normal and ambient occlusion maps");
+        }
+
+        // Fabric Type
+        protected MaterialProperty fabricType = null;
+        protected const string kFabricType = "_FabricType";
+
+        // Base UV set & mask
+        protected MaterialProperty UVBase = null;
+        protected const string kUVBase = "_UVBase";
+        protected MaterialProperty UVMappingMask = null;
+        protected const string kUVMappingMask = "_UVMappingMask";
+
+        // Base color
+        protected MaterialProperty baseColor = null;
+        protected const string kBaseColor = "_BaseColor";
+
+        // Base color map
+        protected MaterialProperty baseColorMap = null;
+        protected const string kBaseColorMap = "_BaseColorMap";
+        protected MaterialProperty smoothness = null;
+
+        // Smoothness
+        protected const string kSmoothness = "_Smoothness";
+
+        // Mask map
+        protected MaterialProperty maskMap = null;
+        protected const string kMaskMap = "_MaskMap";
+
+        // Smoothness remapping
+        protected MaterialProperty smoothnessRemapMin = null;
+        protected const string kSmoothnessRemapMin = "_SmoothnessRemapMin";
+        protected MaterialProperty smoothnessRemapMax = null;
+        protected const string kSmoothnessRemapMax = "_SmoothnessRemapMax";
+
+        // AO remapping
+        protected MaterialProperty aoRemapMin = null;
+        protected const string kAORemapMin = "_AORemapMin";
+        protected MaterialProperty aoRemapMax = null;
+        protected const string kAORemapMax = "_AORemapMax";
+
+        // Normal Scale & Map
+        protected MaterialProperty normalScale = null;
+        protected const string kNormalScale = "_NormalScale";
+        protected MaterialProperty normalMap = null;
+        protected const string kNormalMap = "_NormalMap";
+        // protected MaterialProperty bentNormalMap = null;
+        // protected const string kBentNormalMap = "_BentNormalMap";
+
+        // Tangent Map
+        protected MaterialProperty tangentMap = null;
+        protected const string kTangentMap = "_TangentMap";
+
+        // Fuzz Tint
+        protected MaterialProperty fuzzTint = null;
+        protected const string kFuzzTint = "_FuzzTint";
+
+        // Diffusion profile
+        protected MaterialProperty diffusionProfileID = null;
+        protected const string kDiffusionProfileID = "_DiffusionProfile";
+
+        // Transmission
+        protected MaterialProperty enableTransmission = null;
+        protected const string kEnableTransmission = "_EnableTransmission";
+
+        // Subsurface scattering
+        protected MaterialProperty enableSubsurfaceScattering = null;
+        protected const string kEnableSubsurfaceScattering = "_EnableSubsurfaceScattering";
+        protected MaterialProperty subsurfaceMask = null;
+        protected const string kSubsurfaceMask = "_SubsurfaceMask";
+        protected MaterialProperty subsurfaceMaskMap = null;
+        protected const string kSubsurfaceMaskMap = "_SubsurfaceMaskMap";
+
+        // Thickness
+        protected MaterialProperty thickness = null;
+        protected const string kThickness = "_Thickness";
+        protected MaterialProperty thicknessMap = null;
+        protected const string kThicknessMap = "_ThicknessMap";
+        protected MaterialProperty thicknessRemap = null;
+        protected const string kThicknessRemap = "_ThicknessRemap";
+
+        // UV Detail Set & Mask
+        protected MaterialProperty UVDetail = null;
+        protected const string kUVDetail = "_UVDetail";
+        protected MaterialProperty UVMappingMaskDetail = null;
+        protected const string kUVMappingMaskDetail = "_UVMappingMaskDetail";
+        
+        // Detail Map
+        protected MaterialProperty detailMap = null;
+        protected const string kDetailMap = "_DetailMap";
+
+        // Detail Mask
+        protected MaterialProperty detailMask = null;
+        protected const string kDetailMask = "_DetailMask";
+
+        // Link detail with base
+        protected MaterialProperty linkDetailsWithBase = null;
+        protected const string kLinkDetailsWithBase = "_LinkDetailsWithBase";     
+
+        // Detail adjusting
+        protected MaterialProperty detailAOScale = null;
+        protected const string kDetailAOScale = "_DetailAOScale";
+        protected MaterialProperty detailNormalScale = null;
+        protected const string kDetailNormalScale = "_DetailNormalScale";
+        protected MaterialProperty detailSmoothnessScale = null;
+        protected const string kDetailSmoothnessScale = "_DetailSmoothnessScale";
+
+        // protected MaterialProperty tangentMap = null;
+        // protected const string kTangentMap = "_TangentMap";
+        protected MaterialProperty anisotropy = null;
+        protected const string kAnisotropy = "_Anisotropy";
+        protected MaterialProperty anisotropyMap = null;
+        protected const string kAnisotropyMap = "_AnisotropyMap";
+
+        // UV Emissive Set & Mask
+        protected MaterialProperty UVEmissive = null;
+        protected const string kUVEmissive = "_UVEmissive";
+        protected MaterialProperty UVMappingMaskEmissive = null;
+        protected const string kUVMappingMaskEmissive = "_UVMappingMaskEmissive";
+
+        // Emissive
+        protected MaterialProperty emissiveColor = null;
+        protected const string kEmissiveColor = "_EmissiveColor";
+        protected MaterialProperty emissiveColorMap = null;
+        protected const string kEmissiveColorMap = "_EmissiveColorMap";
+
+        // protected MaterialProperty enableSpecularOcclusion = null;
+        // protected const string kEnableSpecularOcclusion = "_EnableSpecularOcclusion";
+
+
+        override protected void FindMaterialProperties(MaterialProperty[] props)
+        {
+            // Fabric Type
+            fabricType = FindProperty(kFabricType, props);           
+
+            // Base UV set & mask
+            UVBase = FindProperty(kUVBase, props);
+            UVMappingMask = FindProperty(kUVMappingMask, props);
+
+            // Base Color & Map
+            baseColor = FindProperty(kBaseColor, props);
+            baseColorMap = FindProperty(kBaseColorMap, props);
+
+            // Smoothness
+            smoothness = FindProperty(kSmoothness, props);
+
+            // Mask and remapping values
+            maskMap = FindProperty(kMaskMap, props);
+            smoothnessRemapMin = FindProperty(kSmoothnessRemapMin, props);
+            smoothnessRemapMax = FindProperty(kSmoothnessRemapMax, props);
+            aoRemapMin = FindProperty(kAORemapMin, props);
+            aoRemapMax = FindProperty(kAORemapMax, props);
+
+            // Normal map and scale
+            normalMap = FindProperty(kNormalMap, props);
+            normalScale = FindProperty(kNormalScale, props);
+            // bentNormalMap = FindProperty(kBentNormalMap, props);
+
+            // Tangent map
+            tangentMap = FindProperty(kTangentMap, props);
+
+            // Fuzz tint
+            fuzzTint = FindProperty(kFuzzTint, props);
+
+            // Diffusion profile
+            diffusionProfileID = FindProperty(kDiffusionProfileID, props);
+
+            // Transmission
+            enableTransmission = FindProperty(kEnableTransmission, props);
+
+            // Sub surface
+            enableSubsurfaceScattering = FindProperty(kEnableSubsurfaceScattering, props);
+            subsurfaceMask = FindProperty(kSubsurfaceMask, props);
+            subsurfaceMaskMap = FindProperty(kSubsurfaceMaskMap, props);
+
+            // Thickness
+            thickness = FindProperty(kThickness, props);
+            thicknessMap = FindProperty(kThicknessMap, props);
+            thicknessRemap = FindProperty(kThicknessRemap, props);
+
+            // Details Set and Mask
+            UVDetail = FindProperty(kUVDetail, props);
+            UVMappingMaskDetail = FindProperty(kUVMappingMaskDetail, props);
+            
+            // Detail map and rmapping
+            detailMap = FindProperty(kDetailMap, props);
+            detailMask = FindProperty(kDetailMask, props);
+            detailAOScale = FindProperty(kDetailAOScale, props);
+            detailNormalScale = FindProperty(kDetailNormalScale, props);
+            detailSmoothnessScale = FindProperty(kDetailSmoothnessScale, props);
+            linkDetailsWithBase = FindProperty(kLinkDetailsWithBase, props);
+
+            // Anisotropy
+            // tangentMap = FindProperty(kTangentMap, props);
+            anisotropy = FindProperty(kAnisotropy, props);
+            anisotropyMap = FindProperty(kAnisotropyMap, props);
+
+            // UV Emissive set & Mask
+            UVEmissive = FindProperty(kUVEmissive, props);
+            UVMappingMaskEmissive = FindProperty(kUVMappingMaskEmissive, props);
+
+            // Emissive Data
+            emissiveColor = FindProperty(kEmissiveColor, props);
+            emissiveColorMap = FindProperty(kEmissiveColorMap, props);
+
+            // Specular occlusion
+            // enableSpecularOcclusion = FindProperty(kEnableSpecularOcclusion, props);
+        }
+
+        public enum FabricType
+        {
+            Silk,
+            CottonWool,
+        }
+
+        public enum UVBaseMapping
+        {
+            UV0,
+            UV1,
+            UV2,
+            UV3
+        }
+
+        public enum UVDetailMapping
+        {
+            UV0,
+            UV1,
+            UV2,
+            UV3
+        }
+
+        public enum UVEmissiveMapping
+        {
+            UV0,
+            UV1,
+            UV2,
+            UV3
+        }
+
+        protected void BaseUVMappingInputGUI()
+        {
+            m_MaterialEditor.ShaderProperty(UVBase, Styles.UVBaseMappingText);
+
+            UVBaseMapping uvBaseMapping = (UVBaseMapping)UVBase.floatValue;
+
+            float X, Y, Z, W;
+            X = (uvBaseMapping == UVBaseMapping.UV0) ? 1.0f : 0.0f;
+            Y = (uvBaseMapping == UVBaseMapping.UV1) ? 1.0f : 0.0f;
+            Z = (uvBaseMapping == UVBaseMapping.UV2) ? 1.0f : 0.0f;
+            W = (uvBaseMapping == UVBaseMapping.UV3) ? 1.0f : 0.0f;
+
+            UVMappingMask.colorValue = new Color(X, Y, Z, W);
+
+            m_MaterialEditor.TextureScaleOffsetProperty(baseColorMap);
+        }
+
+        protected void BaseInputGUI(Material material)
+        {
+            // The set of inputs offered for customizing the material 
+            EditorGUILayout.LabelField(Styles.InputsText, EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+
+            // Define the UV mapping for the base textures
+            BaseUVMappingInputGUI();
+
+            // The base color map and matching base color value
+            m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap, baseColor);
+
+            // If no mask texture was provided, we display the smoothness value
+            if (maskMap.textureValue == null)
+            {
+                m_MaterialEditor.ShaderProperty(smoothness, Styles.smoothnessText);
+            }
+
+            // If we have a mask map, we do not use values but remapping fields instead
+            m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapSpecularText, maskMap);
+            if (maskMap.textureValue != null)
+            {
+                float remapMin = smoothnessRemapMin.floatValue;
+                float remapMax = smoothnessRemapMax.floatValue;
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.MinMaxSlider(Styles.smoothnessRemappingText, ref remapMin, ref remapMax, 0.0f, 1.0f);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    smoothnessRemapMin.floatValue = remapMin;
+                    smoothnessRemapMax.floatValue = remapMax;
+                }
+
+                float aoMin = aoRemapMin.floatValue;
+                float aoMax = aoRemapMax.floatValue;
+                EditorGUI.BeginChangeCheck();
+                EditorGUILayout.MinMaxSlider(Styles.aoRemappingText, ref aoMin, ref aoMax, 0.0f, 1.0f);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    aoRemapMin.floatValue = aoMin;
+                    aoRemapMax.floatValue = aoMax;
+                }
+            }
+
+            // The primal normal map field
+            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, normalScale);
+
+            // The fuzz tint value (that affects the color of the specular lighting term)
+            m_MaterialEditor.ShaderProperty(fuzzTint, Styles.fuzzTintText);
+
+            // m_MaterialEditor.TexturePropertySingleLine(Styles.bentNormalMapText, bentNormalMap);
+
+            // The diffusion/transmission/subsurface gui
+            ShaderSSSAndTransmissionInputGUI(material);
+
+            // Anisotropy GUI
+            ShaderAnisoInputGUI(material);
+
+            EditorGUI.indentLevel--;
+        }
+
+        protected void DetailsInput(Material material)
+        {
+            EditorGUILayout.LabelField(Styles.detailText, EditorStyles.boldLabel);
+
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.TexturePropertySingleLine(Styles.detailMapNormalText, detailMap);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);
+
+            if (material.GetTexture(kDetailMap))
+            {
+                EditorGUI.indentLevel++;
+
+                m_MaterialEditor.ShaderProperty(UVDetail, Styles.UVDetailMappingText);
+
+                // Setup the UVSet for detail, if planar/triplanar is use for base, it will override the mapping of detail (See shader code)
+                float X, Y, Z, W;
+                X = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f;
+                Y = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f;
+                Z = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV2) ? 1.0f : 0.0f;
+                W = ((UVDetailMapping)UVDetail.floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f;
+                UVMappingMaskDetail.colorValue = new Color(X, Y, Z, W);
+
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(linkDetailsWithBase, Styles.linkDetailsWithBaseText);
+                EditorGUI.indentLevel--;
+
+                m_MaterialEditor.TextureScaleOffsetProperty(detailMap);
+                //m_MaterialEditor.ShaderProperty(detailFuzz1, Styles.detailFuzz1Text);
+                m_MaterialEditor.ShaderProperty(detailAOScale, Styles.detailAOScaleText);
+                m_MaterialEditor.ShaderProperty(detailNormalScale, Styles.detailNormalScaleText);
+                m_MaterialEditor.ShaderProperty(detailSmoothnessScale, Styles.detailSmoothnessScaleText);
+                EditorGUI.indentLevel--;
+            }
+            EditorGUI.indentLevel--;
+        }
+
+        protected void ShaderSSSAndTransmissionInputGUI(Material material)
+        {
+            var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+
+            if (hdPipeline == null)
+                return;
+
+            var diffusionProfileSettings = hdPipeline.diffusionProfileSettings;
+
+            if (hdPipeline.IsInternalDiffusionProfile(diffusionProfileSettings))
+            {
+                EditorGUILayout.HelpBox("No diffusion profile Settings have been assigned to the render pipeline asset.", MessageType.Warning);
+                return;
+            }
+
+         
+            // Enable transmission toggle
+            m_MaterialEditor.ShaderProperty(enableTransmission, Styles.transmissionToggleText);
+
+            // Subsurface toggle and options
+            m_MaterialEditor.ShaderProperty(enableSubsurfaceScattering, Styles.subsurfaceToggleText);
+            if (enableSubsurfaceScattering.floatValue == 1.0f)
+            {
+                m_MaterialEditor.ShaderProperty(subsurfaceMask, Styles.subsurfaceMaskText);
+                m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceMaskMapText, subsurfaceMaskMap);
+            }
+
+            // The thickness sub-menu is toggled if either the transmission or subsurface are requested
+            if (enableSubsurfaceScattering.floatValue == 1.0f || enableTransmission.floatValue == 1.0f)
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap);
+                if (thicknessMap.textureValue != null)
+                {
+                    // Display the remap of texture values.
+                    Vector2 remap = thicknessRemap.vectorValue;
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.MinMaxSlider(Styles.thicknessRemapText, ref remap.x, ref remap.y, 0.0f, 1.0f);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        thicknessRemap.vectorValue = remap;
+                    }
+                }
+                else
+                {
+                    // Allow the user to set the constant value of thickness if no thickness map is provided.
+                    m_MaterialEditor.ShaderProperty(thickness, Styles.thicknessText);
+                }
+            }
+
+            // We only need to display the diffusion profile if we have either transmission or diffusion
+            // TODO: Optimize me
+            if (enableSubsurfaceScattering.floatValue == 1.0f || enableTransmission.floatValue == 1.0f)
+            {
+                var profiles = diffusionProfileSettings.profiles;
+                var names = new GUIContent[profiles.Length + 1];
+                names[0] = new GUIContent("None");
+
+                var values = new int[names.Length];
+                values[0] = DiffusionProfileConstants.DIFFUSION_PROFILE_NEUTRAL_ID;
+
+                for (int i = 0; i < profiles.Length; i++)
+                {
+                    names[i + 1] = new GUIContent(profiles[i].name);
+                    values[i + 1] = i + 1;
+                }
+
+                using (var scope = new EditorGUI.ChangeCheckScope())
+                {
+                    int profileID = (int)diffusionProfileID.floatValue;
+
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        EditorGUILayout.PrefixLabel(Styles.diffusionProfileText);
+
+                        using (new EditorGUILayout.HorizontalScope())
+                        {
+                            profileID = EditorGUILayout.IntPopup(profileID, names, values);
+
+                            if (GUILayout.Button("Goto", EditorStyles.miniButton, GUILayout.Width(50f)))
+                                Selection.activeObject = diffusionProfileSettings;
+                        }
+                    }
+
+                    if (scope.changed)
+                        diffusionProfileID.floatValue = profileID;
+                }
+            }
+        }
+        protected void EmissiveInputGUI(Material material)
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(Styles.emissiveLabelText, EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
+
+            if (material.GetTexture(kEmissiveColorMap))
+            {
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(UVEmissive, Styles.UVMappingEmissiveText);
+                UVBaseMapping uvEmissiveMapping = (UVBaseMapping)UVEmissive.floatValue;
+
+                float X, Y, Z, W;
+                X = (uvEmissiveMapping == UVBaseMapping.UV0) ? 1.0f : 0.0f;
+                Y = (uvEmissiveMapping == UVBaseMapping.UV1) ? 1.0f : 0.0f;
+                Z = (uvEmissiveMapping == UVBaseMapping.UV2) ? 1.0f : 0.0f;
+                W = (uvEmissiveMapping == UVBaseMapping.UV3) ? 1.0f : 0.0f;
+
+                UVMappingMaskEmissive.colorValue = new Color(X, Y, Z, W);
+
+
+                m_MaterialEditor.TextureScaleOffsetProperty(emissiveColorMap);
+                EditorGUI.indentLevel--;
+            }
+
+            EditorGUI.indentLevel--;
+        }
+
+        protected void ShaderAnisoInputGUI(Material material)
+        {
+            // We only have anisotropy for the silk fabric
+            FabricType fabricType = (FabricType)material.GetFloat(kFabricType);
+            if(fabricType == FabricType.Silk)
+            {
+                m_MaterialEditor.TexturePropertySingleLine(Styles.tangentMapText, tangentMap);
+                m_MaterialEditor.ShaderProperty(anisotropy, Styles.anisotropyText);
+                m_MaterialEditor.TexturePropertySingleLine(Styles.anisotropyMapText, anisotropyMap);
+            }
+        }
+
+        protected override void MaterialPropertiesGUI(Material material)
+        {
+            GUILayout.Label("Fabric Options", EditorStyles.boldLabel);
+
+            // The generic type of the fabric (either cotton/wool or silk)
+            EditorGUI.indentLevel++;
+            m_MaterialEditor.ShaderProperty(fabricType, Styles.fabricTypeText);
+            EditorGUI.indentLevel--;
+
+            // Base GUI
+            EditorGUI.indentLevel++;
+            BaseInputGUI(material);
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            // Emissive GUI
+            EditorGUI.indentLevel++;
+            EmissiveInputGUI(material);
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            // Details Input
+            EditorGUI.indentLevel++;
+            DetailsInput(material);
+            EditorGUI.indentLevel--;
+        }
+
+        protected override void VertexAnimationPropertiesGUI()
+        {
+
+        }
+
+        protected override void SetupMaterialKeywordsAndPassInternal(Material material)
+        {
+            SetupMaterialKeywordsAndPass(material);
+        }
+
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
+        static public void SetupMaterialKeywordsAndPass(Material material)
+        {
+            SetupBaseLitKeywords(material);
+            SetupBaseLitMaterialPass(material);
+
+            // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for it
+            CoreUtils.SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap));
+
+            // However, the tangent map flag is only bound to the presence of a tangent map
+            // CoreUtils.SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap));
+
+            // For the moment, we do not support the bent normal map
+            // CoreUtils.SetKeyword(material, "_BENTNORMALMAP", material.GetTexture(kBentNormalMap));
+
+            CoreUtils.SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
+
+            // We do not support specular occlusion for the moment
+            // CoreUtils.SetKeyword(material, "_ENABLESPECULAROCCLUSION", material.GetFloat(kEnableSpecularOcclusion) > 0.0f);
+
+            CoreUtils.SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
+            CoreUtils.SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
+            CoreUtils.SetKeyword(material, "_SUBSURFACE_MASK_MAP", material.GetTexture(kSubsurfaceMaskMap));
+            CoreUtils.SetKeyword(material, "_THICKNESSMAP", material.GetTexture(kThicknessMap));
+            CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap)); 
+
+            // Require and set 
+            bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 || (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV2 || (UVBaseMapping)material.GetFloat(kUVEmissive) == UVBaseMapping.UV2;
+            bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 || (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV3 || (UVBaseMapping)material.GetFloat(kUVEmissive) == UVBaseMapping.UV2;
+
+            if (needUV3)
+            {
+                material.DisableKeyword("_REQUIRE_UV2");
+                material.EnableKeyword("_REQUIRE_UV3");
+            }
+            else if (needUV2)
+            {
+                material.EnableKeyword("_REQUIRE_UV2");
+                material.DisableKeyword("_REQUIRE_UV3");
+            }
+            else
+            {
+                material.DisableKeyword("_REQUIRE_UV2");
+                material.DisableKeyword("_REQUIRE_UV3");
+            }
+
+            // Fetch the fabric type
+            FabricType fabricType = (FabricType)material.GetFloat(kFabricType);
+
+            // If the material is of type cotton/wool we inject it! Otherwise it is necessarily of silk/anisotropy type (we don't inject it to save keywords)
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_COTTON_WOOL", fabricType == FabricType.CottonWool);
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", material.GetFloat(kEnableSubsurfaceScattering) > 0.0f);
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", material.GetFloat(kEnableTransmission) > 0.0f);
+
+            
+        }
+    }
+} // namespace UnityEditor

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.cs.hlsl

+//
+// This file was automatically generated. Please don't edit by hand.
+//
+
+#ifndef FABRIC_CS_HLSL
+#define FABRIC_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Fabric+MaterialFeatureFlags:  static fields
+//
+#define MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL (1)
+#define MATERIALFEATUREFLAGS_FABRIC_SILK (2)
+#define MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING (4)
+#define MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION (8)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Fabric+SurfaceData:  static fields
+//
+#define DEBUGVIEW_FABRIC_SURFACEDATA_MATERIAL_FEATURES (1300)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_BASE_COLOR (1301)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_SPECULAR_OCCLUSION (1302)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_NORMAL (1303)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_NORMAL_VIEW_SPACE (1304)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_SMOOTHNESS (1305)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_AMBIENT_OCCLUSION (1306)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_FUZZ_TINT (1307)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_DIFFUSION_PROFILE (1308)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_SUBSURFACE_MASK (1309)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_THICKNESS (1310)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_TANGENT (1311)
+#define DEBUGVIEW_FABRIC_SURFACEDATA_ANISOTROPY (1312)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Fabric+BSDFData:  static fields
+//
+#define DEBUGVIEW_FABRIC_BSDFDATA_MATERIAL_FEATURES (1350)
+#define DEBUGVIEW_FABRIC_BSDFDATA_DIFFUSE_COLOR (1351)
+#define DEBUGVIEW_FABRIC_BSDFDATA_FRESNEL0 (1352)
+#define DEBUGVIEW_FABRIC_BSDFDATA_AMBIENT_OCCLUSION (1353)
+#define DEBUGVIEW_FABRIC_BSDFDATA_SPECULAR_OCCLUSION (1354)
+#define DEBUGVIEW_FABRIC_BSDFDATA_FUZZ_TINT (1355)
+#define DEBUGVIEW_FABRIC_BSDFDATA_NORMAL_WS (1356)
+#define DEBUGVIEW_FABRIC_BSDFDATA_NORMAL_VIEW_SPACE (1357)
+#define DEBUGVIEW_FABRIC_BSDFDATA_PERCEPTUAL_ROUGHNESS (1358)
+#define DEBUGVIEW_FABRIC_BSDFDATA_DIFFUSION_PROFILE (1359)
+#define DEBUGVIEW_FABRIC_BSDFDATA_SUBSURFACE_MASK (1360)
+#define DEBUGVIEW_FABRIC_BSDFDATA_THICKNESS (1361)
+#define DEBUGVIEW_FABRIC_BSDFDATA_USE_THICK_OBJECT_MODE (1362)
+#define DEBUGVIEW_FABRIC_BSDFDATA_TRANSMITTANCE (1363)
+#define DEBUGVIEW_FABRIC_BSDFDATA_TANGENT_WS (1364)
+#define DEBUGVIEW_FABRIC_BSDFDATA_BITANGENT_WS (1365)
+#define DEBUGVIEW_FABRIC_BSDFDATA_ROUGHNESS_T (1366)
+#define DEBUGVIEW_FABRIC_BSDFDATA_ROUGHNESS_B (1367)
+#define DEBUGVIEW_FABRIC_BSDFDATA_ANISOTROPY (1368)
+
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.Fabric+SurfaceData
+// PackingRules = Exact
+struct SurfaceData
+{
+    uint materialFeatures;
+    float3 baseColor;
+    float specularOcclusion;
+    float3 normalWS;
+    float perceptualSmoothness;
+    float ambientOcclusion;
+    float3 fuzzTint;
+    uint diffusionProfile;
+    float subsurfaceMask;
+    float thickness;
+    float3 tangentWS;
+    float anisotropy;
+};
+
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.Fabric+BSDFData
+// PackingRules = Exact
+struct BSDFData
+{
+    uint materialFeatures;
+    float3 diffuseColor;
+    float3 fresnel0;
+    float ambientOcclusion;
+    float specularOcclusion;
+    float3 fuzzTint;
+    float3 normalWS;
+    float perceptualRoughness;
+    uint diffusionProfile;
+    float subsurfaceMask;
+    float thickness;
+    bool useThickObjectMode;
+    float3 transmittance;
+    float3 tangentWS;
+    float3 bitangentWS;
+    float roughnessT;
+    float roughnessB;
+    float anisotropy;
+};
+
+//
+// Debug functions
+//
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_FABRIC_SURFACEDATA_MATERIAL_FEATURES:
+            result = GetIndexColor(surfacedata.materialFeatures);
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_BASE_COLOR:
+            result = surfacedata.baseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_SPECULAR_OCCLUSION:
+            result = surfacedata.specularOcclusion.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_NORMAL:
+            result = surfacedata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_NORMAL_VIEW_SPACE:
+            result = surfacedata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_SMOOTHNESS:
+            result = surfacedata.perceptualSmoothness.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_AMBIENT_OCCLUSION:
+            result = surfacedata.ambientOcclusion.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_FUZZ_TINT:
+            result = surfacedata.fuzzTint;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_DIFFUSION_PROFILE:
+            result = GetIndexColor(surfacedata.diffusionProfile);
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_SUBSURFACE_MASK:
+            result = surfacedata.subsurfaceMask.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_THICKNESS:
+            result = surfacedata.thickness.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_TANGENT:
+            result = surfacedata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_SURFACEDATA_ANISOTROPY:
+            result = surfacedata.anisotropy.xxx;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_FABRIC_BSDFDATA_MATERIAL_FEATURES:
+            result = GetIndexColor(bsdfdata.materialFeatures);
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_DIFFUSE_COLOR:
+            result = bsdfdata.diffuseColor;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_FRESNEL0:
+            result = bsdfdata.fresnel0;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_AMBIENT_OCCLUSION:
+            result = bsdfdata.ambientOcclusion.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_SPECULAR_OCCLUSION:
+            result = bsdfdata.specularOcclusion.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_FUZZ_TINT:
+            result = bsdfdata.fuzzTint;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_NORMAL_WS:
+            result = bsdfdata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_NORMAL_VIEW_SPACE:
+            result = bsdfdata.normalWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_PERCEPTUAL_ROUGHNESS:
+            result = bsdfdata.perceptualRoughness.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_DIFFUSION_PROFILE:
+            result = GetIndexColor(bsdfdata.diffusionProfile);
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_SUBSURFACE_MASK:
+            result = bsdfdata.subsurfaceMask.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_THICKNESS:
+            result = bsdfdata.thickness.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_USE_THICK_OBJECT_MODE:
+            result = (bsdfdata.useThickObjectMode) ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_TRANSMITTANCE:
+            result = bsdfdata.transmittance;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_TANGENT_WS:
+            result = bsdfdata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_BITANGENT_WS:
+            result = bsdfdata.bitangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_ROUGHNESS_T:
+            result = bsdfdata.roughnessT.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_ROUGHNESS_B:
+            result = bsdfdata.roughnessB.xxx;
+            break;
+        case DEBUGVIEW_FABRIC_BSDFDATA_ANISOTROPY:
+            result = bsdfdata.anisotropy.xxx;
+            break;
+    }
+}
+
+
+#endif

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.hlsl

+//-----------------------------------------------------------------------------
+// SurfaceData and BSDFData
+//-----------------------------------------------------------------------------
+// SurfaceData is defined in Fabric.cs which generates Fabric.cs.hlsl
+#include "Fabric.cs.hlsl"
+// Those define allow to include desired SSS/Transmission functions
+#define MATERIAL_INCLUDE_SUBSURFACESCATTERING
+#define MATERIAL_INCLUDE_TRANSMISSION
+#include "HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl"
+#include "HDRP/Material/NormalBuffer.hlsl"
+#include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
+
+//-----------------------------------------------------------------------------
+// Texture and constant buffer declaration
+//-----------------------------------------------------------------------------
+
+#include "HDRP/Material/LTCAreaLight/LTCAreaLight.hlsl"
+#include "HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.hlsl"
+
+//-----------------------------------------------------------------------------
+// Helper functions/variable specific to this material
+//-----------------------------------------------------------------------------
+
+// Assume bsdfData.normalWS is init
+void FillMaterialAnisotropy(float anisotropy, float3 tangentWS, float3 bitangentWS, inout BSDFData bsdfData)
+{
+    bsdfData.anisotropy = anisotropy;
+    bsdfData.tangentWS = tangentWS;
+    bsdfData.bitangentWS = bitangentWS;
+}
+
+// This function is use to help with debugging and must be implemented by any lit material
+// Implementer must take into account what are the current override component and
+// adjust SurfaceData properties accordingdly
+void ApplyDebugToSurfaceData(float3x3 worldToTangent, inout SurfaceData surfaceData)
+{
+#ifdef DEBUG_DISPLAY
+    // NOTE: THe _Debug* uniforms come from /HDRP/Debug/DebugDisplay.hlsl
+
+    // Override value if requested by user
+    // this can be use also in case of debug lighting mode like diffuse only
+    bool overrideAlbedo = _DebugLightingAlbedo.x != 0.0;
+    bool overrideSmoothness = _DebugLightingSmoothness.x != 0.0;
+    bool overrideNormal = _DebugLightingNormal.x != 0.0;
+
+    if (overrideAlbedo)
+    {
+        float3 overrideAlbedoValue = _DebugLightingAlbedo.yzw;
+        surfaceData.baseColor = overrideAlbedoValue;
+    }
+
+    if (overrideSmoothness)
+    {
+        float overrideSmoothnessValue = _DebugLightingSmoothness.y;
+        surfaceData.perceptualSmoothness = overrideSmoothnessValue;
+    }
+
+    if (overrideNormal)
+    {
+        surfaceData.normalWS = worldToTangent[2];
+    }
+#endif
+}
+
+// This function is similar to ApplyDebugToSurfaceData but for BSDFData
+// Note: This will be available and used in ShaderPassForward.hlsl since in Fabric.shader,
+// just before including the core code of the pass (ShaderPassForward.hlsl) we include
+// Material.hlsl (or Lighting.hlsl which includes it) which in turn includes us,
+// Fabric.shader, via the #if defined(UNITY_MATERIAL_*) glue mechanism.
+void ApplyDebugToBSDFData(inout BSDFData bsdfData)
+{
+#ifdef DEBUG_DISPLAY
+    // Override value if requested by user
+    // this can be use also in case of debug lighting mode like specular only
+    bool overrideSpecularColor = _DebugLightingSpecularColor.x != 0.0;
+
+    if (overrideSpecularColor)
+    {
+        float3 overrideSpecularColor = _DebugLightingSpecularColor.yzw;
+        bsdfData.fresnel0 = overrideSpecularColor;
+    }
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// conversion function for forward
+//-----------------------------------------------------------------------------
+
+BSDFData ConvertSurfaceDataToBSDFData(uint2 positionSS, SurfaceData surfaceData)
+{
+    BSDFData bsdfData;
+    ZERO_INITIALIZE(BSDFData, bsdfData);
+
+    // IMPORTANT: In case of foward or gbuffer pass all enable flags are statically know at compile time, so the compiler can do compile time optimization
+    bsdfData.materialFeatures = surfaceData.materialFeatures;
+
+    bsdfData.diffuseColor = surfaceData.baseColor;
+    bsdfData.specularOcclusion = surfaceData.specularOcclusion;
+    bsdfData.normalWS = surfaceData.normalWS;
+    bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness);
+
+    bsdfData.ambientOcclusion = surfaceData.ambientOcclusion;
+    bsdfData.fuzzTint = surfaceData.fuzzTint;
+    bsdfData.fresnel0 = DEFAULT_SPECULAR_VALUE;
+
+    // Note: we have ZERO_INITIALIZE the struct so bsdfData.anisotropy == 0.0
+    // Note: DIFFUSION_PROFILE_NEUTRAL_ID is 0
+
+    // In forward everything is statically know and we could theorically cumulate all the material features. So the code reflect it.
+    // However in practice we keep parity between deferred and forward, so we should constrain the various features.
+    // The UI is in charge of setuping the constrain, not the code. So if users is forward only and want unleash power, it is easy to unleash by some UI change
+
+    if (HasFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING))
+    {
+        // Assign profile id and overwrite fresnel0
+        FillMaterialSSS(surfaceData.diffusionProfile, surfaceData.subsurfaceMask, bsdfData);
+    }
+
+    if (HasFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION))
+    {
+        // Assign profile id and overwrite fresnel0
+        FillMaterialTransmission(surfaceData.diffusionProfile, surfaceData.thickness, bsdfData);
+    }
+
+    if (!HasFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL))
+    {
+        FillMaterialAnisotropy(surfaceData.anisotropy, surfaceData.tangentWS, cross(surfaceData.normalWS, surfaceData.tangentWS), bsdfData);
+    }
+
+    // roughnessT and roughnessB are clamped, and are meant to be used with punctual and directional lights.
+    // perceptualRoughness is not clamped, and is meant to be used for IBL.
+    // perceptualRoughness can be modify by FillMaterialClearCoatData, so ConvertAnisotropyToClampRoughness must be call after
+    ConvertAnisotropyToClampRoughness(bsdfData.perceptualRoughness, bsdfData.anisotropy, bsdfData.roughnessT, bsdfData.roughnessB);
+
+    ApplyDebugToBSDFData(bsdfData);
+
+    return bsdfData;
+}
+
+//-----------------------------------------------------------------------------
+// Debug method (use to display values)
+//-----------------------------------------------------------------------------
+
+// This function call the generated debug function and allow to override the debug output if needed
+void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
+{
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
+}
+
+// This function call the generated debug function and allow to override the debug output if needed
+void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB)
+{
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
+}
+
+//-----------------------------------------------------------------------------
+// PreLightData
+//
+// Make sure we respect naming conventions to reuse ShaderPassForward as is,
+// ie struct (even if opaque to the ShaderPassForward) name is PreLightData,
+// GetPreLightData prototype.
+//-----------------------------------------------------------------------------
+
+// Precomputed lighting data to send to the various lighting functions
+struct PreLightData
+{
+    float NdotV;        // Could be negative due to normal mapping, use ClampNdotV()
+    float partLambdaV;
+
+    // IBL
+    float3 iblR;                     // Reflected specular direction, used for IBL in EvaluateBSDF_Env()
+    float  iblPerceptualRoughness;
+
+    float3 specularFGD;              // Store preintegrated BSDF for both specular and diffuse
+    float  diffuseFGD;
+};
+
+// This function is call to precompute heavy calculation before lightloop
+PreLightData GetPreLightData(float3 V, PositionInputs posInput, inout BSDFData bsdfData)
+{
+    PreLightData preLightData;
+    // Don't init to zero to allow to track warning about uninitialized data
+
+    float3 N = bsdfData.normalWS;
+    preLightData.NdotV = dot(N, V);
+    preLightData.iblPerceptualRoughness = bsdfData.perceptualRoughness;
+
+    float NdotV = ClampNdotV(preLightData.NdotV);
+
+    float unused;
+    float3 iblN;
+
+    // Reminder: This is a static if resolve at compile time
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_SILK))
+    {
+        GetPreIntegratedFGDGGXAndDisneyDiffuse(NdotV, preLightData.iblPerceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, unused);
+
+        float TdotV = dot(bsdfData.tangentWS, V);
+        float BdotV = dot(bsdfData.bitangentWS, V);
+
+        preLightData.partLambdaV = GetSmithJointGGXAnisoPartLambdaV(TdotV, BdotV, NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
+
+        // perceptualRoughness is use as input and output here
+        GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N, V, bsdfData.anisotropy, preLightData.iblPerceptualRoughness, iblN, preLightData.iblPerceptualRoughness);
+    }
+    else
+    {
+        preLightData.partLambdaV = 0.0;
+        iblN = N;
+
+        GetPreIntegratedFGDCharlieAndFabricLambert(NdotV, preLightData.iblPerceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, unused);
+    }
+
+    preLightData.iblR = reflect(-V, iblN);
+
+    return preLightData;
+}
+
+//-----------------------------------------------------------------------------
+// bake lighting function
+//-----------------------------------------------------------------------------
+
+// This define allow to say that we implement a ModifyBakedDiffuseLighting function to be call in PostInitBuiltinData
+#define MODIFY_BAKED_DIFFUSE_LIGHTING
+
+void ModifyBakedDiffuseLighting(float3 V, PositionInputs posInput, SurfaceData surfaceData, inout BuiltinData builtinData)
+{
+    // To get the data we need to do the whole process - compiler should optimize everything
+    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(posInput.positionSS, surfaceData);
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    // Add GI transmission contribution to bakeDiffuseLighting, we then drop backBakeDiffuseLighting (i.e it is not used anymore, this save VGPR)
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION))
+    {
+        builtinData.bakeDiffuseLighting += builtinData.backBakeDiffuseLighting * bsdfData.transmittance;
+    }
+
+    // For SSS we need to take into account the state of diffuseColor 
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING))
+    {
+        bsdfData.diffuseColor = GetModifiedDiffuseColorForSSS(bsdfData);
+    }
+
+    // Premultiply (back) bake diffuse lighting information with diffuse pre-integration
+    builtinData.bakeDiffuseLighting *= preLightData.diffuseFGD * bsdfData.diffuseColor;
+}
+
+//-----------------------------------------------------------------------------
+// light transport functions
+//-----------------------------------------------------------------------------
+
+LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+{
+    LightTransportData lightTransportData;
+
+    // DiffuseColor for lightmapping
+    lightTransportData.diffuseColor = bsdfData.diffuseColor;
+    lightTransportData.emissiveColor = builtinData.emissiveColor;
+
+    return lightTransportData;
+}
+
+//-----------------------------------------------------------------------------
+// LightLoop related function (Only include if required)
+// HAS_LIGHTLOOP is define in Lighting.hlsl
+//-----------------------------------------------------------------------------
+
+#ifdef HAS_LIGHTLOOP
+
+#ifndef _SURFACE_TYPE_TRANSPARENT
+// For /Lighting/LightEvaluation.hlsl:
+#define USE_DEFERRED_DIRECTIONAL_SHADOWS // Deferred shadows are always enabled for opaque objects
+#endif
+
+#include "HDRP/Material/MaterialEvaluation.hlsl"
+#include "HDRP/Lighting/LightEvaluation.hlsl"
+
+//-----------------------------------------------------------------------------
+// BSDF share between directional light, punctual light and area light (reference)
+//-----------------------------------------------------------------------------
+
+// Ref: https://www.slideshare.net/jalnaga/custom-fabric-shader-for-unreal-engine-4
+// For Fabric we have two type of BRDF
+// Non-Metal: Cotton, deim, flax and common fabrics
+// Cotton: Roughness of 1.0 (unless wet) - Fuzz rim - specular color is white but is looked like desaturated.
+// Metal: Silk, satin, velvet, nylon and polyester
+// Silk: Roughness 0.3 - 0.7 - anisotropic - varying specular color
+
+// This function apply BSDF. Assumes that NdotL is positive.
+void BSDF(  float3 V, float3 L, float NdotL, float3 positionWS, PreLightData preLightData, BSDFData bsdfData,
+            out float3 diffuseLighting,
+            out float3 specularLighting)
+{
+    float LdotV, NdotH, LdotH, NdotV, invLenLV;
+    GetBSDFAngle(V, L, NdotL, preLightData.NdotV, LdotV, NdotH, LdotH, NdotV, invLenLV);
+
+    // Fabric are dieletric but we simulate forward scattering effect with colored specular (fuzz tint term)
+	float3 F = F_Schlick(bsdfData.fresnel0, LdotH);
+
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL))
+    {
+        float D = D_Charlie(NdotH, bsdfData.roughnessT);
+        // V_Charlie is expensive, use approx with V_Ashikhmin instead
+        // float Vis = V_Charlie(NdotL, NdotV, bsdfData.roughness);
+        float Vis = V_Ashikhmin(NdotL, NdotV);
+
+        specularLighting = F * Vis * D;
+
+        // Note: diffuseLighting is multiply by color in PostEvaluateBSDF
+        diffuseLighting = FabricLambert(bsdfData.roughnessT);
+    }
+    else // MATERIALFEATUREFLAGS_FABRIC_SILK
+    {
+        // For silk we just use a tinted anisotropy
+        float3 H = (L + V) * invLenLV;
+
+        // For anisotropy we must not saturate these values
+        float TdotH = dot(bsdfData.tangentWS, H);
+        float TdotL = dot(bsdfData.tangentWS, L);
+        float BdotH = dot(bsdfData.bitangentWS, H);
+        float BdotL = dot(bsdfData.bitangentWS, L);
+
+        // TODO: Do comparison between this correct version and the one from isotropic and see if there is any visual difference
+        float DV = DV_SmithJointGGXAniso(   TdotH, BdotH, NdotH, NdotV, TdotL, BdotL, NdotL,
+                                            bsdfData.roughnessT, bsdfData.roughnessB, preLightData.partLambdaV);
+
+        specularLighting = F * DV;
+
+        // Note: diffuseLighting is multiply by color in PostEvaluateBSDF
+        diffuseLighting = DisneyDiffuse(NdotV, NdotL, LdotV, bsdfData.perceptualRoughness);
+    }
+
+    specularLighting *= bsdfData.fuzzTint;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Directional
+//-----------------------------------------------------------------------------
+
+DirectLighting EvaluateBSDF_Directional(LightLoopContext lightLoopContext,
+                                        float3 V, PositionInputs posInput, PreLightData preLightData,
+                                        DirectionalLightData lightData, BSDFData bsdfData,
+                                        BuiltinData builtinData)
+{
+    DirectLighting lighting;
+    ZERO_INITIALIZE(DirectLighting, lighting);
+
+    float3 L = -lightData.forward;
+    float3 N = bsdfData.normalWS;
+    float NdotL = dot(N, L);
+
+    float3 transmittance = float3(0.0, 0.0, 0.0);
+    if (HasFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_THIN_THICKNESS))
+    {
+        // Caution: This function modify N and contactShadowIndex
+        transmittance = PreEvaluateDirectionalLightTransmission(NdotL, lightData, bsdfData, N, lightData.contactShadowIndex); // contactShadowIndex is only modify for the code of this function
+    }
+
+    float3 color;
+    float attenuation;
+    EvaluateLight_Directional(lightLoopContext, posInput, lightData, builtinData, N, L, color, attenuation);
+
+    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
+
+    UNITY_BRANCH if (intensity > 0.0)
+    {
+        BSDF(V, L, NdotL, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
+
+        lighting.diffuse  *= intensity * lightData.diffuseScale;
+        lighting.specular *= intensity * lightData.specularScale;
+    }
+
+    // The mixed thickness mode is not supported by directional lights due to poor quality and high performance impact.
+    if (HasFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_THIN_THICKNESS))
+    {
+        float  NdotV = ClampNdotV(preLightData.NdotV);
+        float  LdotV = dot(L, V);
+        // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
+        lighting.diffuse += EvaluateTransmission(bsdfData, transmittance, NdotL, NdotV, LdotV, attenuation * lightData.diffuseScale);
+    }
+
+    // Save ALU by applying light and cookie colors only once.
+    lighting.diffuse  *= color;
+    lighting.specular *= color;
+
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // Only lighting, not BSDF
+        lighting.diffuse = color * intensity * lightData.diffuseScale;
+    }
+#endif
+
+    return lighting;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Punctual (supports spot, point and projector lights)
+//-----------------------------------------------------------------------------
+
+DirectLighting EvaluateBSDF_Punctual(LightLoopContext lightLoopContext,
+                                     float3 V, PositionInputs posInput,
+                                     PreLightData preLightData, LightData lightData, BSDFData bsdfData, BuiltinData builtinData)
+{
+    DirectLighting lighting;
+    ZERO_INITIALIZE(DirectLighting, lighting);
+
+    float3 L;
+    float3 lightToSample;
+    float4 distances; // {d, d^2, 1/d, d_proj}
+    GetPunctualLightVectors(posInput.positionWS, lightData, L, lightToSample, distances);
+
+    float3 N = bsdfData.normalWS;
+    float  NdotL = dot(N, L);
+
+    float3 transmittance = float3(0.0, 0.0, 0.0);
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION))
+    {
+        // Caution: This function modify N and lightData.contactShadowIndex
+        transmittance = PreEvaluatePunctualLightTransmission(lightLoopContext, posInput, distances.x, NdotL, L, bsdfData, N, lightData);
+    }
+
+    float3 color;
+    float attenuation;
+    EvaluateLight_Punctual(lightLoopContext, posInput, lightData, builtinData, N, L,
+                           lightToSample, distances, color, attenuation);
+
+    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
+
+    UNITY_BRANCH if (intensity > 0.0)
+    {
+        // Simulate a sphere light with this hack
+        // Note that it is not correct with our pre-computation of PartLambdaV (mean if we disable the optimization we will not have the
+        // same result) but we don't care as it is a hack anyway
+        bsdfData.roughnessT = max(bsdfData.roughnessT, lightData.minRoughness);
+        bsdfData.roughnessB = max(bsdfData.roughnessB, lightData.minRoughness);
+
+        BSDF(V, L, NdotL, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
+
+        lighting.diffuse  *= intensity * lightData.diffuseScale;
+        lighting.specular *= intensity * lightData.specularScale;
+    }
+
+    // Save ALU by applying light and cookie colors only once.
+    lighting.diffuse  *= color;
+    lighting.specular *= color;
+
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION))
+    {
+        float  NdotV = ClampNdotV(preLightData.NdotV);
+        float  LdotV = dot(L, V);
+        // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
+        lighting.diffuse += EvaluateTransmission(bsdfData, transmittance, NdotL, NdotV, LdotV, attenuation * lightData.diffuseScale);
+    }
+
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // Only lighting, not BSDF
+        lighting.diffuse = color * intensity * lightData.diffuseScale;
+    }
+#endif
+
+    return lighting;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Line
+//-----------------------------------------------------------------------------
+
+DirectLighting EvaluateBSDF_Line(   LightLoopContext lightLoopContext,
+                                    float3 V, PositionInputs posInput,
+                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData, BuiltinData builtinData)
+{
+    DirectLighting lighting;
+    ZERO_INITIALIZE(DirectLighting, lighting);
+
+    // TODO
+
+    return lighting;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Rect
+//-----------------------------------------------------------------------------
+
+DirectLighting EvaluateBSDF_Rect(   LightLoopContext lightLoopContext,
+                                    float3 V, PositionInputs posInput,
+                                    PreLightData preLightData, LightData lightData, BSDFData bsdfData, BuiltinData builtinData)
+{
+    DirectLighting lighting;
+    ZERO_INITIALIZE(DirectLighting, lighting);
+
+    // TODO
+
+    return lighting;
+}
+
+DirectLighting EvaluateBSDF_Area(LightLoopContext lightLoopContext,
+    float3 V, PositionInputs posInput,
+    PreLightData preLightData, LightData lightData,
+    BSDFData bsdfData, BuiltinData builtinData)
+{
+    if (lightData.lightType == GPULIGHTTYPE_LINE)
+    {
+        return EvaluateBSDF_Line(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, builtinData);
+    }
+    else
+    {
+        return EvaluateBSDF_Rect(lightLoopContext, V, posInput, preLightData, lightData, bsdfData, builtinData);
+    }
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_SSLighting for screen space lighting
+// ----------------------------------------------------------------------------
+
+IndirectLighting EvaluateBSDF_SSLighting(LightLoopContext lightLoopContext,
+                                            float3 V, PositionInputs posInput,
+                                            PreLightData preLightData, BSDFData bsdfData,
+                                            EnvLightData envLightData,
+                                            int GPUImageBasedLightingType,
+                                            inout float hierarchyWeight)
+{
+    IndirectLighting lighting;
+    ZERO_INITIALIZE(IndirectLighting, lighting);
+
+    // TODO
+
+    return lighting;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Env
+// ----------------------------------------------------------------------------
+
+// _preIntegratedFGD and _CubemapLD are unique for each BRDF
+IndirectLighting EvaluateBSDF_Env(  LightLoopContext lightLoopContext,
+                                    float3 V, PositionInputs posInput,
+                                    PreLightData preLightData, EnvLightData lightData, BSDFData bsdfData,
+                                    int influenceShapeType, int GPUImageBasedLightingType,
+                                    inout float hierarchyWeight)
+{
+    IndirectLighting lighting;
+    ZERO_INITIALIZE(IndirectLighting, lighting);
+
+    if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION)
+        return lighting;
+
+    float3 envLighting;
+    float3 positionWS = posInput.positionWS;
+    float weight = 1.0;
+
+    float3 R = preLightData.iblR;
+
+    if ((lightData.envIndex & 1) == ENVCACHETYPE_CUBEMAP)
+    {
+        R = GetSpecularDominantDir(bsdfData.normalWS, R, preLightData.iblPerceptualRoughness, ClampNdotV(preLightData.NdotV));
+        // When we are rough, we tend to see outward shifting of the reflection when at the boundary of the projection volume
+        // Also it appear like more sharp. To avoid these artifact and at the same time get better match to reference we lerp to original unmodified reflection.
+        // Formula is empirical.
+        float roughness = PerceptualRoughnessToRoughness(preLightData.iblPerceptualRoughness);
+        R = lerp(R, preLightData.iblR, saturate(smoothstep(0, 1, roughness * roughness)));
+    }
+
+    // Note: using influenceShapeType and projectionShapeType instead of (lightData|proxyData).shapeType allow to make compiler optimization in case the type is know (like for sky)
+    EvaluateLight_EnvIntersection(positionWS, bsdfData.normalWS, lightData, influenceShapeType, R, weight);
+
+    float iblMipLevel;
+    // TODO: We need to match the PerceptualRoughnessToMipmapLevel formula for planar, so we don't do this test (which is specific to our current lightloop)
+    // Specific case for Texture2Ds, their convolution is a gaussian one and not a GGX one - So we use another roughness mip mapping.
+#if !defined(SHADER_API_METAL)
+    if (IsEnvIndexTexture2D(lightData.envIndex))
+    {
+        // Empirical remapping
+        iblMipLevel = PositivePow(preLightData.iblPerceptualRoughness, 0.8) * uint(max(_ColorPyramidScale.z - 1, 0));
+    }
+    else
+#endif
+    {
+        iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);
+    }
+
+    float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R, iblMipLevel);
+    weight *= preLD.a; // Used by planar reflection to discard pixel
+
+    envLighting = preLightData.specularFGD * preLD.rgb;
+
+    UpdateLightingHierarchyWeights(hierarchyWeight, weight);
+    envLighting *= weight * lightData.multiplier;
+    lighting.specularReflected = envLighting;
+
+    return lighting;
+}
+
+//-----------------------------------------------------------------------------
+// PostEvaluateBSDF
+// ----------------------------------------------------------------------------
+
+void PostEvaluateBSDF(  LightLoopContext lightLoopContext,
+                        float3 V, PositionInputs posInput,
+                        PreLightData preLightData, BSDFData bsdfData, BuiltinData builtinData, AggregateLighting lighting,
+                        out float3 diffuseLighting, out float3 specularLighting)
+{
+    AmbientOcclusionFactor aoFactor;
+    GetScreenSpaceAmbientOcclusionMultibounce(posInput.positionSS, preLightData.NdotV, bsdfData.perceptualRoughness, bsdfData.ambientOcclusion, bsdfData.specularOcclusion, bsdfData.diffuseColor, bsdfData.fresnel0, aoFactor);
+    ApplyAmbientOcclusionFactor(aoFactor, builtinData, lighting);
+
+    // Subsurface scattering mode
+    float3 modifiedDiffuseColor = GetModifiedDiffuseColorForSSS(bsdfData);
+
+    // Apply the albedo to the direct diffuse lighting (only once). The indirect (baked)
+    // diffuse lighting has already multiply the albedo in ModifyBakedDiffuseLighting().
+    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + builtinData.bakeDiffuseLighting + builtinData.emissiveColor;
+    specularLighting = lighting.direct.specular + lighting.indirect.specularReflected;
+
+    // TODO: Multiscattering for cloth?
+
+#ifdef DEBUG_DISPLAY
+    PostEvaluateBSDFDebugDisplay(aoFactor, builtinData, lighting, bsdfData.diffuseColor, diffuseLighting, specularLighting);
+#endif
+}
+
+#endif // #ifdef HAS_LIGHTLOOP

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.shader

+Shader "HDRenderPipeline/Fabric"
+{
+    Properties
+    {
+        // Following set of parameters represent the parameters node inside the MaterialGraph.
+        // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
+
+        // Reminder. Color here are in linear but the UI (color picker) do the conversion sRGB to linear
+        // Be careful, do not change the name here to _Color. It will conflict with the "fake" parameters (see end of properties) required for GI.
+        
+        // Fabric type
+        [Enum(Silk, 0, CottonWool, 1)] _FabricType("Fabric Type", Float) = 0
+
+        // Value used to define which uv channel is used for the first set of textures
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVBase("UV Set for base", Float) = 0
+        [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
+
+        // Base color
+        _BaseColor("BaseColor", Color) = (1,1,1,1)
+        _BaseColorMap("BaseColorMap", 2D) = "white" {}
+
+        // Normal map
+        _NormalMap("NormalMap", 2D) = "bump" {}     // Tangent space normal map
+        _NormalScale("_NormalScale", Range(0.0, 2.0)) = 1
+
+        // Tangent map
+        _TangentMap("TangentMap", 2D) = "bump" {}
+
+        // Smoothness values (overriden by the mask map)
+        _Smoothness("Smoothness", Range(0.0, 1.0)) = 1.0
+    
+        // The mask texture and the matching remapping values for it        
+        _MaskMap("MaskMap", 2D) = "white" {}
+        _AORemapMin("AORemapMin", Float) = 0.0
+        _AORemapMax("AORemapMax", Float) = 1.0
+        _SmoothnessRemapMin("SmoothnessRemapMin", Float) = 0.0
+        _SmoothnessRemapMax("SmoothnessRemapMax", Float) = 1.0
+
+        // TODO
+        //_BentNormalMap("_BentNormalMap", 2D) = "bump" {}
+
+        // Fuzz Tint
+        _FuzzTint("FuzzTint", Color) = (1.0, 1.0, 1.0)
+
+        // Detail Data
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0
+        [HideInInspector] _UVMappingMaskDetail("_UVMappingMaskDetail", Color) = (1, 0, 0, 0)
+        _DetailMap("DetailMap", 2D) = "black" {}
+        _DetailMask("DetailMask", 2D) = "white" {}
+        _DetailAOScale("_DetailAOScale", Range(0.0, 2.0)) = 1
+        _DetailNormalScale("_DetailNormalScale", Range(0.0, 2.0)) = 1
+        _DetailSmoothnessScale("_DetailSmoothnessScale", Range(0.0, 2.0)) = 1
+        [ToggleUI] _LinkDetailsWithBase("LinkDetailsWithBase", Float) = 1.0
+
+        // Emissive Data
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVEmissive("UV Set for emissive", Float) = 0
+        [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
+        _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
+        [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
+
+        // Anisotropy Data
+        _Anisotropy("Anisotropy", Range(-1.0, 1.0)) = 0
+        _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
+
+        // Diffusion Data
+        _DiffusionProfile("Diffusion Profile", Int) = 0
+
+        // Transmission Data
+        [ToggleUI]  _EnableTransmission("_EnableTransmission", Float) = 0.0
+
+        // Subsurface Data
+        [ToggleUI]  _EnableSubsurfaceScattering("_EnableSubsurfaceScattering", Float) = 0.0
+        _SubsurfaceMask("Subsurface Radius", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMaskMap("Subsurface Radius Map", 2D) = "white" {}
+
+        // Thickness Data
+        _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
+        _ThicknessMap("Thickness Map", 2D) = "white" {}
+        _ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
+
+        //[ToggleUI]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
+
+        // Transparency
+        [ToggleUI] _PreRefractionPass("PreRefractionPass", Float) = 0.0
+
+        [ToggleUI]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
+        _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
+
+        // Stencil state
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting  (fixed at compile time)
+        [HideInInspector] _StencilWriteMask("_StencilWriteMask", Int) = 7 // StencilMask.Lighting  (fixed at compile time)
+        [HideInInspector] _StencilRefMV("_StencilRefMV", Int) = 128 // StencilLightingUsage.RegularLighting  (fixed at compile time)
+        [HideInInspector] _StencilWriteMaskMV("_StencilWriteMaskMV", Int) = 128 // StencilMask.ObjectsVelocity  (fixed at compile time)
+
+        // Blending state
+        [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
+        [HideInInspector] _BlendMode("__blendmode", Float) = 0.0
+        [HideInInspector] _SrcBlend("__src", Float) = 1.0
+        [HideInInspector] _DstBlend("__dst", Float) = 0.0
+        [HideInInspector] _ZWrite("__zw", Float) = 1.0
+        [HideInInspector] _CullMode("__cullmode", Float) = 2.0
+        [HideInInspector] _ZTestDepthEqualForOpaque("_ZTestDepthEqualForOpaque", Int) = 4 // Less equal
+
+        [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 1.0
+        [ToggleUI] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0
+
+        _EmissionColor("Color", Color) = (1, 1, 1)
+
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+    }
+
+    HLSLINCLUDE
+
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
+    //-------------------------------------------------------------------------------------
+    // Variant
+    //-------------------------------------------------------------------------------------
+
+    #pragma shader_feature _ALPHATEST_ON
+
+    #pragma shader_feature _NORMALMAP
+    #pragma shader_feature _MASKMAP
+    #pragma shader_feature _BENTNORMALMAP
+    #pragma shader_feature _ENABLESPECULAROCCLUSION
+    #pragma shader_feature _TANGENTMAP
+    #pragma shader_feature _ANISOTROPYMAP
+    #pragma shader_feature _DETAIL_MAP
+    #pragma shader_feature _SUBSURFACE_MASK_MAP
+    #pragma shader_feature _THICKNESSMAP
+    #pragma shader_feature _EMISSIVE_COLOR_MAP
+
+    // Keyword for transparent
+    #pragma shader_feature _SURFACE_TYPE_TRANSPARENT
+    #pragma shader_feature _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
+    #pragma shader_feature _BLENDMODE_PRESERVE_SPECULAR_LIGHTING
+    #pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT
+
+    // MaterialFeature are used as shader feature to allow compiler to optimize properly
+    #pragma shader_feature _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
+    #pragma shader_feature _MATERIAL_FEATURE_TRANSMISSION
+    #pragma shader_feature _MATERIAL_FEATURE_COTTON_WOOL
+    
+    //enable GPU instancing support
+    #pragma multi_compile_instancing
+
+    //-------------------------------------------------------------------------------------
+    // Define
+    //-------------------------------------------------------------------------------------
+
+    #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl
+
+    //-------------------------------------------------------------------------------------
+    // Include
+    //-------------------------------------------------------------------------------------
+
+    #include "CoreRP/ShaderLibrary/Common.hlsl"
+    #include "HDRP/ShaderPass/FragInputs.hlsl"
+    #include "HDRP/ShaderPass/ShaderPass.cs.hlsl"
+
+    //-------------------------------------------------------------------------------------
+    // variable declaration
+    //-------------------------------------------------------------------------------------
+
+    #include "HDRP/Material/Fabric/FabricProperties.hlsl"
+
+    // All our shaders use same name for entry point
+    #pragma vertex Vert
+    #pragma fragment Frag
+
+    ENDHLSL
+
+    SubShader
+    {
+        // This tags allow to use the shader replacement features
+        Tags{ "RenderPipeline" = "HDRenderPipeline" "RenderType" = "HDFabricShader" }
+
+        // Caution: The outline selection in the editor use the vertex shader/hull/domain shader of the first pass declare. So it should not be the meta pass.
+
+        Pass
+        {
+            Name "Depth prepass"
+            Tags{ "LightMode" = "DepthForwardOnly" }
+
+            Cull[_CullMode]
+
+            ZWrite On
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "HDRP/ShaderVariables.hlsl"
+            #include "HDRP/Material/Material.hlsl"
+            #include "ShaderPass/FabricDepthPass.hlsl"
+            #include "FabricData.hlsl"
+            #include "HDRP/ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        // Extracts information for lightmapping, GI (emission, albedo, ...)
+        // This pass it not used during regular rendering.
+        Pass
+        {
+            Name "META"
+            Tags{ "LightMode" = "Meta" }
+
+            Cull Off
+
+            HLSLPROGRAM
+
+            // 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.
+
+            #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "HDRP/ShaderVariables.hlsl"
+            #include "HDRP/Material/Material.hlsl"
+            #include "ShaderPass/FabricSharePass.hlsl"
+            #include "FabricData.hlsl"
+            #include "HDRP/ShaderPass/ShaderPassLightTransport.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "ShadowCaster"
+            Tags{ "LightMode" = "ShadowCaster" }
+
+            Cull[_CullMode]
+
+            ZClip [_ZClip]
+            ZWrite On
+            ZTest LEqual
+
+            ColorMask 0
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_SHADOWS
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
+            #include "HDRP/ShaderVariables.hlsl"
+            #include "HDRP/Material/Material.hlsl"
+
+            #include "ShaderPass/FabricDepthPass.hlsl"
+            #include "FabricData.hlsl"
+            #include "HDRP/ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        // Fabric shader always render in forward
+        Pass
+        {
+            Name "Forward" // Name is not used
+            Tags { "LightMode" = "ForwardOnly" }
+
+            Stencil
+            {
+                WriteMask [_StencilWriteMask]
+                Ref [_StencilRef]
+                Comp Always
+                Pass Replace
+            }
+
+            Blend [_SrcBlend] [_DstBlend]
+            // In case of forward we want to have depth equal for opaque alpha tested mesh
+            ZTest [_ZTestDepthEqualForOpaque]
+            ZWrite [_ZWrite]
+
+            HLSLPROGRAM
+
+            #pragma multi_compile _ DEBUG_DISPLAY
+            #pragma multi_compile _ LIGHTMAP_ON
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+
+            // #include "HDRP/Lighting/Forward.hlsl" : nothing left in there.
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+
+            #define SHADERPASS SHADERPASS_FORWARD
+            #include "HDRP/ShaderVariables.hlsl"
+            #ifdef DEBUG_DISPLAY
+            #include "HDRP/Debug/DebugDisplay.hlsl"
+            #endif
+            #include "HDRP/Lighting/Lighting.hlsl"
+            //...this will include #include "HDRP/Material/Material.hlsl" but also LightLoop which the forward pass directly uses.
+
+            #include "ShaderPass/FabricSharePass.hlsl"
+            #include "FabricData.hlsl"
+            #include "HDRP/ShaderPass/ShaderPassForward.hlsl"
+
+            ENDHLSL
+        }
+
+    }
+
+    CustomEditor "Experimental.Rendering.HDPipeline.FabricGUI"
+}

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/ShaderPass.meta

+fileFormatVersion: 2
+guid: f79d82fdc4e5c2041973e2f65f9666fd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.cs.hlsl.meta

+fileFormatVersion: 2
+guid: c8253363006e4a9428a799250ac5b2b0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.cs.meta

+fileFormatVersion: 2
+guid: 93e2716a30b38c44c9ed06602a0fc923
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.hlsl.meta

+fileFormatVersion: 2
+guid: 9d559bc1da0ed3b49a6c549d3b90b375
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.shader.meta

+fileFormatVersion: 2
+guid: 6a6a4e0a7fa7acb4db5434242d16a50f
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/FabricData.hlsl.meta

+fileFormatVersion: 2
+guid: f77d977338f663640bdae0ddeb5d3426
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/FabricProperties.hlsl.meta

+fileFormatVersion: 2
+guid: 1cac3ffd4f003744fb5730a5c48ba9b5
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/Fabric.cs

+using System;
+using UnityEngine.Rendering;
+
+//-----------------------------------------------------------------------------
+// structure definition
+//-----------------------------------------------------------------------------
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public class Fabric : RenderPipelineMaterial
+    {
+        // If change, be sure it match what is done in Lit.hlsl: MaterialFeatureFlagsFromGBuffer
+        // Material bit mask must match the size define LightDefinitions.s_MaterialFeatureMaskFlags value
+        [GenerateHLSL(PackingRules.Exact)]
+        public enum MaterialFeatureFlags
+        {
+            FabricCottonWool = 1 << 0,
+            FabricSilk = 1 << 1,
+            FabricSubsurfaceScattering = 1 << 2,
+            FabricTransmission = 1 << 3
+        };
+
+        //-----------------------------------------------------------------------------
+        // SurfaceData
+        //-----------------------------------------------------------------------------
+
+        // Main structure that store the user data (i.e user input of master node in material graph)
+        [GenerateHLSL(PackingRules.Exact, false, true, 1300)]
+        public struct SurfaceData
+        {
+            [SurfaceDataAttributes("MaterialFeatures")]
+            public uint materialFeatures;
+
+            // Standard
+            [SurfaceDataAttributes("Base Color", false, true)]
+            public Vector3 baseColor;
+            [SurfaceDataAttributes("Specular Occlusion")]
+            public float specularOcclusion;
+
+            [SurfaceDataAttributes(new string[] { "Normal", "Normal View Space" }, true)]
+            public Vector3 normalWS;
+            [SurfaceDataAttributes("Smoothness")]
+            public float perceptualSmoothness;
+
+            [SurfaceDataAttributes("Ambient Occlusion")]
+            public float ambientOcclusion;
+
+            // Fuzz Tint
+            [SurfaceDataAttributes("Fuzz Tint", false, true)]
+            public Vector3 fuzzTint;
+
+            // MaterialFeature dependent attribute
+
+            // SSS
+            [SurfaceDataAttributes("Diffusion Profile")]
+            public uint diffusionProfile;
+            [SurfaceDataAttributes("Subsurface Mask")]
+            public float subsurfaceMask;
+
+            // Transmission
+            // + Diffusion Profile
+            [SurfaceDataAttributes("Thickness")]
+            public float thickness;
+
+            // Anisotropic
+            [SurfaceDataAttributes("Tangent", true)]
+            public Vector3 tangentWS;
+            [SurfaceDataAttributes("Anisotropy")]
+            public float anisotropy; // anisotropic ratio(0->no isotropic; 1->full anisotropy in tangent direction, -1->full anisotropy in bitangent direction)
+        };
+
+        //-----------------------------------------------------------------------------
+        // BSDFData
+        //-----------------------------------------------------------------------------
+
+        [GenerateHLSL(PackingRules.Exact, false, true, 1350)]
+        public struct BSDFData
+        {
+            public uint materialFeatures;
+
+            [SurfaceDataAttributes("", false, true)]
+            public Vector3 diffuseColor;
+            public Vector3 fresnel0;
+
+            public float ambientOcclusion;
+            public float specularOcclusion;
+
+            public Vector3 fuzzTint;
+
+            [SurfaceDataAttributes(new string[] { "Normal WS", "Normal View Space" }, true)]
+            public Vector3 normalWS;
+            public float perceptualRoughness;
+
+            // MaterialFeature dependent attribute
+
+            // SSS
+            public uint diffusionProfile;
+            public float subsurfaceMask;
+
+            // Transmission
+            // + Diffusion Profile
+            public float thickness;
+            public bool useThickObjectMode; // Read from the diffusion profile
+            public Vector3 transmittance;   // Precomputation of transmittance
+
+            // Anisotropic
+            [SurfaceDataAttributes("", true)]
+            public Vector3 tangentWS;
+            [SurfaceDataAttributes("", true)]
+            public Vector3 bitangentWS;
+            public float roughnessT;
+            public float roughnessB;
+            public float anisotropy;
+        };
+
+        //-----------------------------------------------------------------------------
+        // Init precomputed textures
+        //-----------------------------------------------------------------------------
+
+        public Fabric() {}
+
+        public override void Build(HDRenderPipelineAsset hdAsset)
+        {
+            PreIntegratedFGD.instance.Build(PreIntegratedFGD.FGDIndex.FGD_CharlieAndFabricLambert);
+            //LTCAreaLight.instance.Build();
+        }
+
+        public override void Cleanup()
+        {
+            PreIntegratedFGD.instance.Cleanup(PreIntegratedFGD.FGDIndex.FGD_CharlieAndFabricLambert);
+            //LTCAreaLight.instance.Cleanup();
+        }
+
+        public override void RenderInit(CommandBuffer cmd)
+        {
+            PreIntegratedFGD.instance.RenderInit(PreIntegratedFGD.FGDIndex.FGD_CharlieAndFabricLambert, cmd);
+        }
+
+        public override void Bind()
+        {
+            PreIntegratedFGD.instance.Bind(PreIntegratedFGD.FGDIndex.FGD_CharlieAndFabricLambert);
+            //LTCAreaLight.instance.Bind();
+        }
+    }
+}

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/FabricProperties.hlsl

+// ===========================================================================
+//                              WARNING:
+// On PS4, texture/sampler declarations need to be outside of CBuffers
+// Otherwise those parameters are not bound correctly at runtime.
+// ===========================================================================
+
+TEXTURE2D(_BaseColorMap);
+SAMPLER(sampler_BaseColorMap);
+
+TEXTURE2D(_MaskMap);
+SAMPLER(sampler_MaskMap);
+//TEXTURE2D(_BentNormalMap); // Reuse sampler from normal map
+//SAMPLER(sampler_BentNormalMap);
+
+TEXTURE2D(_NormalMap);
+SAMPLER(sampler_NormalMap);
+
+TEXTURE2D(_DetailMask);
+SAMPLER(sampler_DetailMask);
+TEXTURE2D(_DetailMap);
+SAMPLER(sampler_DetailMap);
+
+TEXTURE2D(_TangentMap);
+SAMPLER(sampler_TangentMap);
+
+TEXTURE2D(_AnisotropyMap);
+SAMPLER(sampler_AnisotropyMap);
+
+TEXTURE2D(_SubsurfaceMaskMap);
+SAMPLER(sampler_SubsurfaceMaskMap);
+TEXTURE2D(_ThicknessMap);
+SAMPLER(sampler_ThicknessMap);
+
+TEXTURE2D(_EmissiveColorMap);
+SAMPLER(sampler_EmissiveColorMap);
+
+CBUFFER_START(UnityPerMaterial)
+
+float4 _UVMappingMask;
+float4 _UVMappingMaskDetail;
+float4 _UVMappingMaskEmissive;
+
+float4 _BaseColor;
+float4 _BaseColorMap_ST;
+float4 _BaseColorMap_TexelSize;
+float4 _BaseColorMap_MipInfo;
+
+float4 _FuzzTint;
+
+float _AlphaCutoff;
+
+float _EnableSpecularOcclusion;
+
+float _Smoothness;
+float _SmoothnessRemapMin;
+float _SmoothnessRemapMax;
+float _AORemapMin;
+float _AORemapMax;
+
+float _NormalScale;
+
+float4 _DetailMap_ST;
+float _DetailFuzz1;
+float _DetailAOScale;
+float _DetailNormalScale;
+float _DetailSmoothnessScale;
+
+float _Anisotropy;
+
+int   _DiffusionProfile;
+float _SubsurfaceMask;
+float _Thickness;
+float4 _ThicknessRemap;
+
+float4 _EmissiveColorMap_ST;
+float4 _EmissiveColor;
+float _AlbedoAffectEmissive;
+
+CBUFFER_END

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/ShaderPass/FabricDepthPass.hlsl

+#ifndef SHADERPASS
+#error Undefine_SHADERPASS
+#endif
+
+#ifdef _ALPHATEST_ON
+#define ATTRIBUTES_NEED_TEXCOORD0
+
+#define VARYINGS_NEED_TEXCOORD0
+#endif //..._ALPHATEST_ON
+
+// This include will define the various Attributes/Varyings structure
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/ShaderPass/FabricDepthPass.hlsl.meta

+fileFormatVersion: 2
+guid: 9946a17aceea4734d82fcd2044af9b69
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/ShaderPass/FabricSharePass.hlsl

+#ifndef SHADERPASS
+#error Undefine_SHADERPASS
+#endif
+
+// This first set of define allow to say which attributes will be use by the mesh in the vertex and domain shader (for tesselation)
+
+// Attributes
+#define ATTRIBUTES_NEED_NORMAL
+#define ATTRIBUTES_NEED_TANGENT // Always present as we require it also in case of anisotropic lighting
+#define ATTRIBUTES_NEED_TEXCOORD0
+#define ATTRIBUTES_NEED_TEXCOORD1
+#define ATTRIBUTES_NEED_COLOR
+
+#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || defined(DEBUG_DISPLAY) || (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
+#define ATTRIBUTES_NEED_TEXCOORD2
+#endif
+#if defined(_REQUIRE_UV3) || defined(DEBUG_DISPLAY)
+#define ATTRIBUTES_NEED_TEXCOORD3
+#endif
+
+// Varying - Use for pixel shader
+// This second set of define allow to say which varyings will be output in the vertex (no more tesselation)
+#define VARYINGS_NEED_POSITION_WS
+#define VARYINGS_NEED_TANGENT_TO_WORLD
+#define VARYINGS_NEED_TEXCOORD0
+#define VARYINGS_NEED_TEXCOORD1
+#ifdef ATTRIBUTES_NEED_TEXCOORD2
+#define VARYINGS_NEED_TEXCOORD2
+#endif
+#ifdef ATTRIBUTES_NEED_TEXCOORD3
+#define VARYINGS_NEED_TEXCOORD3
+#endif
+#define VARYINGS_NEED_COLOR
+
+// This include will define the various Attributes/Varyings structure
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/ShaderPass/FabricSharePass.hlsl.meta

+fileFormatVersion: 2
+guid: fdaa5fc96d0e0b8438df418fc7a19ae0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/Fabric/FabricData.hlsl

+//-------------------------------------------------------------------------------------
+// Fill SurfaceData/Builtin data function
+//-------------------------------------------------------------------------------------
+#include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
+#include "HDRP/Material/MaterialUtilities.hlsl"
+#include "HDRP/Material/BuiltinUtilities.hlsl"
+
+void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
+{
+    // Initial value of the material features
+    surfaceData.materialFeatures = 0;
+    
+// Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one)
+#ifdef _MATERIAL_FEATURE_COTTON_WOOL
+    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL;
+#endif
+
+#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
+    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING;
+#endif
+
+#ifdef _MATERIAL_FEATURE_TRANSMISSION
+    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION;
+#endif
+    
+    // Generate the primary uv coordinates
+    float2 uvBase = _UVMappingMask.x * input.texCoord0 +
+                    _UVMappingMask.y * input.texCoord1 +
+                    _UVMappingMask.z * input.texCoord2 +
+                    _UVMappingMask.w * input.texCoord3;
+
+    // Apply tiling and offset
+    uvBase = uvBase * _BaseColorMap_ST.xy + _BaseColorMap_ST.zw;
+
+
+    // Generate the detail uv coordinates
+    float2 uvDetails =  _UVMappingMaskDetail.x * input.texCoord0 +
+                        _UVMappingMaskDetail.y * input.texCoord1 +
+                        _UVMappingMaskDetail.z * input.texCoord2 +
+                        _UVMappingMaskDetail.w * input.texCoord3;
+
+    // Apply offset and tiling
+    uvDetails = uvDetails * _DetailMap_ST.xy + _DetailMap_ST.zw;
+
+// We need to start by reading the detail (if any available to override the initial values)
+#ifdef _DETAIL_MAP
+    float4 detailMasks = SAMPLE_TEXTURE2D(_DetailMask, sampler_DetailMask, uvDetails);
+    float2 detailAOAndSmoothness = SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, uvDetails).rb;
+    float detailAO = detailAOAndSmoothness.r * 2.0 - 1.0;
+    float detailSmoothness = detailAOAndSmoothness.g * 2.0 - 1.0;
+
+    // Handle the normal detail
+    float2 detailDerivative = UnpackDerivativeNormalRGorAG(SAMPLE_TEXTURE2D(_DetailMap, sampler_DetailMap, uvDetails), _DetailNormalScale);
+    float3 detailGradient =  SurfaceGradientFromTBN(detailDerivative, input.worldToTangent[0], input.worldToTangent[1]);
+#else
+    float3 detailGradient = float3(0.0, 0.0, 0.0);
+    float detailMask = 0.0;
+#endif
+    
+    // The base color of the object mixed with the base color texture
+    surfaceData.baseColor = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, uvBase).rgb * _BaseColor.rgb;
+
+    // Extract the alpha value (will be useful if we need to trigger the alpha test)
+    float alpha = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, uvBase).a * _BaseColor.a;
+
+#ifdef _NORMALMAP
+    float2 derivative = UnpackDerivativeNormalRGorAG(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, uvBase), _NormalScale);
+    #ifdef _DETAIL_MAP
+        float3 gradient =  SurfaceGradientFromTBN(derivative, input.worldToTangent[0], input.worldToTangent[1]) + detailGradient * detailMasks.x;
+    #else
+        float3 gradient =  SurfaceGradientFromTBN(derivative, input.worldToTangent[0], input.worldToTangent[1]);
+    #endif
+    surfaceData.normalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], gradient);
+#else
+    surfaceData.normalWS = input.worldToTangent[2];
+#endif
+
+#ifdef _TANGENTMAP
+    float3 tangentTS = UnpackNormalmapRGorAG(SAMPLE_TEXTURE2D(_TangentMap, sampler_TangentMap, uvBase, 1.0));
+    surfaceData.tangentWS = TransformTangentToWorld(tangentTS, input.worldToTangent);
+#else
+    surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
+#endif
+
+    // Make the tagent match the normal
+    surfaceData.tangentWS = Orthonormalize(input.worldToTangent[0], surfaceData.normalWS);
+
+#ifdef _MASKMAP
+    float4 maskSample = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, uvBase);
+#endif
+
+#ifdef _MASKMAP
+    surfaceData.ambientOcclusion = lerp(_AORemapMin, _AORemapMax, maskSample.y);
+    surfaceData.perceptualSmoothness = lerp(_SmoothnessRemapMin, _SmoothnessRemapMax, maskSample.w);
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
+#else
+    surfaceData.perceptualSmoothness = _Smoothness;
+    surfaceData.ambientOcclusion = 1.0;
+    surfaceData.specularOcclusion = 1.0;
+#endif
+
+// If a detail map was provided, modify the matching smoothness
+#ifdef _DETAIL_MAP
+    float smoothnessDetailSpeed = saturate(abs(detailSmoothness) * _DetailSmoothnessScale);
+    float smoothnessOverlay = lerp(surfaceData.perceptualSmoothness, (detailSmoothness < 0.0) ? 0.0 : 1.0, smoothnessDetailSpeed);
+    surfaceData.perceptualSmoothness = lerp(surfaceData.perceptualSmoothness, saturate(smoothnessOverlay), detailMask.x);
+#endif
+    
+// If a detail map was provided, modify the matching ao
+#ifdef _DETAIL_MAP
+    float aoDetailSpeed = saturate(abs(detailAO) * _DetailAOScale);
+    float aoOverlay = lerp(surfaceData.ambientOcclusion, (aoDetailSpeed < 0.0) ? 0.0 : 1.0, aoDetailSpeed);
+    surfaceData.ambientOcclusion = lerp(surfaceData.ambientOcclusion, saturate(aoOverlay), detailMask.x);
+#endif
+
+    // Propagate the fuzz tint
+    surfaceData.fuzzTint = _FuzzTint.xyz;
+
+#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
+    surfaceData.diffusionProfile = _DiffusionProfile;
+    #ifdef _SUBSURFACEMASK
+        float4 subSurfaceMaskSample = SAMPLE_TEXTURE2D(_SubsurfaceMaskMap, sampler_SubsurfaceMaskMap, uvBase);
+        surfaceData.subsurfaceMask = subSurfaceMaskSample.x;
+    #else
+        surfaceData.subsurfaceMask = _SubsurfaceMask;
+    #endif
+#else
+    surfaceData.subsurfaceMask = 0.0;
+    surfaceData.diffusionProfile = 0;
+#endif
+
+#ifdef _MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION
+    float4 subSurfaceMaskSample = SAMPLE_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, uvBase);
+    surfaceData.thickness = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_ThicknessMap), _ThicknessMapChannelMask);
+    surfaceData.thickness = lerp(_ThicknessMapRange.x, _ThicknessMapRange.y, surfaceData.thickness);
+    surfaceData.thickness = lerp(_Thickness, surfaceData.thickness, _ThicknessUseMap);
+    surfaceData.thickness = _ThicknessRemap.x +  surfaceData.thickness * _ThicknessRemap.y;
+#else
+    surfaceData.thickness = _Thickness;
+#endif
+
+#ifdef _ANISOTROPYMAP
+    surfaceData.anisotropy = SAMPLE_TEXTURE2D(_AnisotropyMap, sample_AnisotropyMap, uvBase).x;
+#else
+    surfaceData.anisotropy = _Anisotropy;
+#endif
+
+#ifdef _ALPHATEST_ON
+    DoAlphaTest(alpha, _AlphaCutoff);
+#endif
+
+#if defined(DEBUG_DISPLAY)
+    if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
+    {
+        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, uvBase, _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.baseColor);
+    }
+#endif
+
+    // -------------------------------------------------------------
+    // Builtin Data
+    // -------------------------------------------------------------
+
+    // For back lighting we use the oposite vertex normal 
+    InitBuiltinData(alpha, surfaceData.normalWS, -input.worldToTangent[2], input.positionRWS, input.texCoord1, input.texCoord2, builtinData);
+    
+    // Support the emissive color and map
+    builtinData.emissiveColor = _EmissiveColor * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
+#ifdef _EMISSIVE_COLOR_MAP
+    // Generate the primart uv coordinates
+    float2 uvEmissive = _UVMappingMaskEmissive.x * input.texCoord0 +
+                    _UVMappingMaskEmissive.y * input.texCoord1 +
+                    _UVMappingMaskEmissive.z * input.texCoord2 +
+                    _UVMappingMaskEmissive.w * input.texCoord3;
+    
+    uvEmissive = uvEmissive * _EmissiveColorMap_ST.xy + _EmissiveColorMap_ST.zw;
+
+    builtinData.emissiveColor *= SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, uvEmissive).rgb;
+#endif
+
+    PostInitBuiltinData(V, posInput, surfaceData, builtinData);
+}