Merge branch 'master' into fix/coupling-hdlight-workflow

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/CommonLighting.hlsl

     return area;
 }
 
+// ref: Practical Realtime Strategies for Accurate Indirect Occlusion
+// http://blog.selfshadow.com/publications/s2016-shading-course/#course_content
+// Original Cone-Cone method with cosine weighted assumption (p129 s2016_pbs_activision_occlusion)
+real GetSpecularOcclusionFromBentAO(real3 V, real3 bentNormalWS, real3 normalWS, real ambientOcclusion, real roughness)
+{
+    // Retrieve cone angle
+    // Ambient occlusion is cosine weighted, thus use following equation. See slide 129
+    real cosAv = sqrt(1.0 - ambientOcclusion);
+    roughness = max(roughness, 0.01); // Clamp to 0.01 to avoid edge cases
+    real cosAs = exp2((-log(10.0) / log(2.0)) * Sq(roughness));
+    real cosB = dot(bentNormalWS, reflect(-V, normalWS));
+    return SphericalCapIntersectionSolidArea(cosAv, cosAs, cosB) / (TWO_PI * (1.0 - cosAs));
+}
+
 // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
 real ComputeWrappedDiffuseLighting(real NdotL, real w)
 {
     real3 localY = cross(localZ, localX);
 
     return real3x3(localX, localY, localZ);
+}
+
+// Construct a right-handed view-dependent orthogonal basis around the normal:
+// b0-b2 is the view-normal aka reflection plane.
+real3x3 GetOrthoBasisViewNormal(real3 V, real3 N, real unclampedNdotV, bool testSingularity = false)
+{
+    real3x3 orthoBasisViewNormal;
+    if (testSingularity && (abs(1.0 - unclampedNdotV) <= FLT_EPS))
+    {
+        // In this case N == V, and azimuth orientation around N shouldn't matter for the caller,
+        // we can use any quaternion-based method, like Frisvad or Reynold's (Pixar): 
+        orthoBasisViewNormal = GetLocalFrame(N);
+    }
+    else
+    {
+        orthoBasisViewNormal[0] = normalize(V - N * unclampedNdotV);
+        orthoBasisViewNormal[2] = N;
+        orthoBasisViewNormal[1] = cross(orthoBasisViewNormal[2], orthoBasisViewNormal[0]);
+    }
+    return orthoBasisViewNormal;
 }
 
 #endif // UNITY_COMMON_LIGHTING_INCLUDED

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
 //-----------------------------------------------------------------------------
 
 
 void ConvertRoughnessToAnisotropy(real roughnessT, real roughnessB, out real anisotropy)
 {
-    anisotropy = ((roughnessT - roughnessB) / (roughnessT + roughnessB + 0.0001));
+    anisotropy = ((roughnessT - roughnessB) / max(roughnessT + roughnessB, 0.0001));
 }
 
 // Same as ConvertAnisotropyToRoughness but
     return sqrt(2.0 / (variance + 2.0));
 }
 
+// Normal Map Filtering - This must match HDRP\Editor\AssetProcessors\NormalMapFilteringTexturePostprocessor.cs - highestVarianceAllowed (TODO: Move in core)
+#define NORMALMAP_HIGHEST_VARIANCE 0.03125
+
+float DecodeVariance(float gradientW)
+{
+    return gradientW * NORMALMAP_HIGHEST_VARIANCE;
+}
+
 // Return modified perceptualSmoothness based on provided variance (get from GeometricNormalVariance + TextureNormalVariance)
 float NormalFiltering(float perceptualSmoothness, float variance, float threshold)
 {
 
-    return 1.0 - RoughnessToPerceptualRoughness(sqrt(squaredRoughness));
+    return RoughnessToPerceptualSmoothness(sqrt(squaredRoughness));
 }
 
 // Reference: Error Reduction and Simplification for Shading Anti-Aliasing
 // like Toksvig.
 float TextureNormalVariance(float avgNormalLength)
 {
+    float variance = 0.0;
+
     if (avgNormalLength < 1.0)
     {
         float avgNormLen2 = avgNormalLength * avgNormalLength;
         // Relationship between gaussian lobe and vMF lobe is 2 * variance = 1 / (2 * kappa) = roughness^2
         // (Equation 36 of  Normal map filtering based on The Order : 1886 SIGGRAPH course notes implementation).
         // So to get variance we must use variance = 1 / (4 * kappa)
-        return 0.25 * kappa;
+        variance = 0.25 / kappa;
-    return 0.0;
+    return variance;
 }
 
 float TextureNormalFiltering(float perceptualSmoothness, float avgNormalLength, float threshold)

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

 
 ## [3.3.0-preview]
 
+### Fixed
+- Fix an issue where the screen where darken when rendering camera preview
+- Fix display correct target platform when showing message to inform user that a platform is not supported
+- Remove workaround for metal and vulkan in normal buffer encoding/decoding
+- Fixed an issue with color picker not working in forward
+
+### Changed
+- Changed default reflection probe to be 256x256x6 and array size to be 64
+- Increased the precision when comparing Planar or HD reflection probe volumes
+
+### Added
+- Added a new Fabric shader model that supports Silk and Cotton/Wool
+
 ## [3.2.0-preview]
 
 ### Added
 - Fix planar reflections that were not working with tile/cluster (olbique matrix)
 - Fix debug menu at runtime not working after nested prefab PR come to trunk
 - Fix scrolling issue in density volume
-- Fix an issue where the screen where darken when rendering camera preview
-- Fix display correct target platform when showing message to inform user that a platform is not supported
-- Remove workaround for metal and vulkan in normal buffer encoding/decoding
 
 ### Changed
 - Shader code refactor: Split MaterialUtilities file in two parts BuiltinUtilities (independent of FragInputs) and MaterialUtilities (Dependent of FragInputs)

com.unity.render-pipelines.high-definition/HDRP/Editor/AssetProcessors/NormalMapFilteringTexturePostprocessor.cs.meta

 fileFormatVersion: 2
-guid: 3ceae5765b6bbee4fb4f76acdaae9130
+guid: db58d0243609fae48a1a8f3460bdbd4c
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/HDAdditionalLightDataEditor.cs

         {
         }
     }
+
+    public class HDAdditionalLightDataGizmoDrawer
+    {
+        [DrawGizmo(GizmoType.Selected | GizmoType.Active)]
+        static void DrawGizmoForHDAdditionalLightData(HDAdditionalLightData src, GizmoType gizmoType)
+        {
+            bool selected = (gizmoType & GizmoType.Selected) != 0;
+
+            var light = src.gameObject.GetComponent<Light>();
+            var gizmoColor = light.color;
+            gizmoColor.a = selected ? 1.0f : 0.3f; // Fade for the gizmo
+            Gizmos.color = Handles.color = gizmoColor;
+
+            if (src.lightTypeExtent == LightTypeExtent.Punctual)
+            {
+                switch (light.type)
+                {
+                    case LightType.Directional:
+                        CoreLightEditorUtilities.DrawDirectionalLightGizmo(light);
+                        break;
+                    case LightType.Point:
+                        CoreLightEditorUtilities.DrawPointlightGizmo(light, selected);
+                        break;
+                    case LightType.Spot:
+                        if (src.spotLightShape == SpotLightShape.Cone)
+                            CoreLightEditorUtilities.DrawSpotlightGizmo(light, src.GetInnerSpotPercent01(), selected);
+                        else if (src.spotLightShape == SpotLightShape.Pyramid)
+                            HDLightEditorUtilities.DrawFrustumlightGizmo(light);
+                        else if (src.spotLightShape == SpotLightShape.Box)
+                            HDLightEditorUtilities.DrawFrustumlightGizmo(light);
+                        break;
+                }
+            }
+            else
+            {
+                switch (src.lightTypeExtent)
+                {
+                    case LightTypeExtent.Rectangle:
+                        CoreLightEditorUtilities.DrawArealightGizmo(light);
+                        break;
+                    case LightTypeExtent.Line:
+                        CoreLightEditorUtilities.DrawArealightGizmo(light);
+                        break;
+                }
+            }
+
+            if (selected)
+            {
+                // Trace a ray down to better locate the light location
+                Ray ray = new Ray(src.gameObject.transform.position, Vector3.down);
+                RaycastHit hit;
+                if (Physics.Raycast(ray, out hit))
+                {
+                    Handles.color = Color.green;
+                    Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
+                    Handles.DrawLine(src.gameObject.transform.position, hit.point);
+                    Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
+
+                    Handles.color = Color.red;
+                    Handles.zTest = UnityEngine.Rendering.CompareFunction.Greater;
+                    Handles.DrawLine(src.gameObject.transform.position, hit.point);
+                    Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
+                }
+            }
+        }
+    }
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/HDLightExplorerExtension.cs

                         lightDataPairing[light].hdAdditionalLightData.intensity = intensity;
                     }
                 }), 
-                new LightingExplorerTableColumn(LightingExplorerTableColumn.DataType.Float, HDStyles.Intensity, "m_Intensity", 60, (r, prop, dep) =>                // 9: Unit
+                new LightingExplorerTableColumn(LightingExplorerTableColumn.DataType.Float, HDStyles.Unit, "m_Intensity", 60, (r, prop, dep) =>                // 9: Unit
                 {
                     Light light = prop.serializedObject.targetObject as Light;
                     LightUnit unit = lightDataPairing[light].hdAdditionalLightData.lightUnit;

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/Lighting/Light/HDAdditionalLightData.cs

 using System;
 #if UNITY_EDITOR
 using UnityEditor;
+using UnityEditor.Experimental.Rendering;
 using UnityEditor.Experimental.Rendering.HDPipeline;
 #endif
 using UnityEngine.Serialization;
 
                 return useColorTemperatureProperty.boolValue;
             }
-        }
-
-        private void DrawGizmos(bool selected)
-        {
-            var light = gameObject.GetComponent<Light>();
-            var gizmoColor = light.color;
-            gizmoColor.a = selected ? 1.0f : 0.3f; // Fade for the gizmo
-            Gizmos.color = Handles.color = gizmoColor;
-
-            if (lightTypeExtent == LightTypeExtent.Punctual)
-            {
-                switch (light.type)
-                {
-                    case LightType.Directional:
-                        HDLightEditorUtilities.DrawDirectionalLightGizmo(light);
-                        break;
-                    case LightType.Point:
-                        HDLightEditorUtilities.DrawPointlightGizmo(light, selected);
-                        break;
-                    case LightType.Spot:
-                        if (spotLightShape == SpotLightShape.Cone)
-                            HDLightEditorUtilities.DrawSpotlightGizmo(light, selected);
-                        else if (spotLightShape == SpotLightShape.Pyramid)
-                            HDLightEditorUtilities.DrawFrustumlightGizmo(light);
-                        else if (spotLightShape == SpotLightShape.Box)
-                            HDLightEditorUtilities.DrawFrustumlightGizmo(light);
-                        break;
-                }
-            }
-            else
-            {
-                switch (lightTypeExtent)
-                {
-                    case LightTypeExtent.Rectangle:
-                        HDLightEditorUtilities.DrawArealightGizmo(light);
-                        break;
-                    case LightTypeExtent.Line:
-                        HDLightEditorUtilities.DrawArealightGizmo(light);
-                        break;
-                }
-            }
-
-            if (selected)
-            {
-                DrawVerticalRay();
-            }
-        }
-
-        // Trace a ray down to better locate the light location
-        private void DrawVerticalRay()
-        {
-            Ray ray = new Ray(transform.position, Vector3.down);
-            RaycastHit hit;
-            if (Physics.Raycast(ray, out hit))
-            {
-                Handles.color = Color.green;
-                Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
-                Handles.DrawLine(transform.position, hit.point);
-                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
-
-                Handles.color = Color.red;
-                Handles.zTest = UnityEngine.Rendering.CompareFunction.Greater;
-                Handles.DrawLine(transform.position, hit.point);
-                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
-            }
-        }
-
-        private void OnDrawGizmos()
-        {
-            // DrawGizmos(false);
-        }
-
-        private void OnDrawGizmosSelected()
-        {
-            DrawGizmos(true);
         }
 
         // TODO: There are a lot of old != current checks and assignation in this function, maybe think about using another system ?

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightLoop/LightLoop.cs

                     m_areaLightCount = areaLightCount;
 
                     // Redo everything but this time with envLights
+                    Debug.Assert(k_MaxEnvLightsOnScreen <= 256); //for key construction
                     int envLightCount = 0;
 
                     var totalProbes = cullResults.visibleReflectionProbes.Count + reflectionProbeCullResults.visiblePlanarReflectionProbeCount;
 
         static float CalculateProbeLogVolume(Bounds bounds)
         {
-            float boxVolume = 8 * bounds.extents.x * bounds.extents.y * bounds.extents.z;
-            float logVolume = Mathf.Clamp(256 + Mathf.Log(boxVolume, 1.05f), 0, 4095); // Allow for negative exponents
+            //Notes:
+            // - 1+ term is to prevent having negative values in the log result
+            // - 1000* is too keep 3 digit after the dot while we truncate the result later
+            // - 1048575 is 2^20-1 as we pack the result on 20bit later
+            float boxVolume = 8f* bounds.extents.x * bounds.extents.y * bounds.extents.z;
+            float logVolume = Mathf.Clamp(Mathf.Log(1 + boxVolume, 1.05f)*1000, 0, 1048575);
-            lightVolumeType = (LightVolumeType)((sortKey >> 17) & 0x3);
-            probeIndex = (int)(sortKey & 0xFFFF);
-            listType = (int)((sortKey >> 16) & 1);
+            lightVolumeType = (LightVolumeType)((sortKey >> 9) & 0x3);
+            probeIndex = (int)(sortKey & 0xFF);
+            listType = (int)((sortKey >> 8) & 1);
-            // 12 bit volume, 3 bit LightVolumeType, 1 bit list type, 16 bit index
-            return (uint)logVolume << 20 | (uint)lightVolumeType << 17 | listType << 16 | ((uint)probeIndex & 0xFFFF);
+            // 20 bit volume, 3 bit LightVolumeType, 1 bit list type, 8 bit index
+            return (uint)logVolume << 12 | (uint)lightVolumeType << 9 | listType << 8 | ((uint)probeIndex & 0xFF);
         }
 
         void VoxelLightListGeneration(CommandBuffer cmd, HDCamera hdCamera, Matrix4x4[] projscrArr, Matrix4x4[] invProjscrArr, RenderTargetIdentifier cameraDepthBufferRT)

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

     // If user provide bent normal then we process a better term
 #if (defined(_BENTNORMALMAP0) || defined(_BENTNORMALMAP1) || defined(_BENTNORMALMAP2) || defined(_BENTNORMALMAP3)) && defined(_ENABLESPECULAROCCLUSION)
     // If we have bent normal and ambient occlusion, process a specular occlusion
-    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData);
+    #ifdef SPECULAR_OCCLUSION_USE_SPTD
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAOPivot(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
+    #else
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
+    #endif
 #elif defined(_MASKMAP0) || defined(_MASKMAP1) || defined(_MASKMAP2) || defined(_MASKMAP3)
     surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(dot(surfaceData.normalWS, V), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
 #else

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
     preLightData.ltcTransformSpecular._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, s_linear_clamp_sampler, uv, LTC_GGX_MATRIX_INDEX, 0);
 
     // Construct a right-handed view-dependent orthogonal basis around the normal
-    preLightData.orthoBasisViewNormal[0] = normalize(V - N * preLightData.NdotV); // Do not clamp NdotV here
-    preLightData.orthoBasisViewNormal[2] = N;
-    preLightData.orthoBasisViewNormal[1] = cross(preLightData.orthoBasisViewNormal[2], preLightData.orthoBasisViewNormal[0]);
+    preLightData.orthoBasisViewNormal = GetOrthoBasisViewNormal(V, N, preLightData.NdotV);
 
     preLightData.ltcTransformCoat = 0.0;
     if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
 
     // If refraction is enable we use the transmittanceMask to lerp between current diffuse lighting and refraction value
     // Physically speaking, transmittanceMask should be 1, but for artistic reasons, we let the value vary
+    //
+    // Note we also transfer the refracted light (lighting.indirect.specularTransmitted) into diffuseLighting
+    // since we know it won't be further processed: it is called at the end of the LightLoop(), but doing this
+    // enables opacity to affect it (in ApplyBlendMode()) while the rest of specularLighting escapes it.
 #if HAS_REFRACTION
     diffuseLighting = lerp(diffuseLighting, lighting.indirect.specularTransmitted, bsdfData.transmittanceMask);
 #endif

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

 #include "HDRP/Material/MaterialUtilities.hlsl"
 #include "HDRP/Material/Decal/DecalUtilities.hlsl"
 
-// TODO: move this function to commonLighting.hlsl once validated it work correctly
-float GetSpecularOcclusionFromBentAO(float3 V, float3 bentNormalWS, SurfaceData surfaceData)
-{
-    // Retrieve cone angle
-    // Ambient occlusion is cosine weighted, thus use following equation. See slide 129
-    float cosAv = sqrt(1.0 - surfaceData.ambientOcclusion);
-    float roughness = max(PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness), 0.01); // Clamp to 0.01 to avoid edge cases
-    float cosAs = exp2((-log(10.0)/log(2.0)) * Sq(roughness));
-    float cosB = dot(bentNormalWS, reflect(-V, surfaceData.normalWS));
-
-    return SphericalCapIntersectionSolidArea(cosAv, cosAs, cosB) / (TWO_PI * (1.0 - cosAs));
-}
+//#include "HDRP/Material/SphericalCapPivot/SPTDistribution.hlsl"
+//#define SPECULAR_OCCLUSION_USE_SPTD
 
 // Struct that gather UVMapping info of all layers + common calculation
 // This is use to abstract the mapping that can differ on layers
     // If user provide bent normal then we process a better term
 #if defined(_BENTNORMALMAP) && defined(_ENABLESPECULAROCCLUSION)
     // If we have bent normal and ambient occlusion, process a specular occlusion
-    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData);
+    #ifdef SPECULAR_OCCLUSION_USE_SPTD
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAOPivot(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
+    #else
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
+    #endif
 #elif defined(_MASKMAP)
     surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
 #else

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

         #ifdef SURFACE_GRADIENT
         normalTS += detailNormalTS * detailMask;
         #else
-        normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask);
+        normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask); // todo: detailMask should lerp the angle of the quaternion rotation, not the normals
         #endif
     #endif
 #else
     surfaceData.baseColor = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).rgb * ADD_IDX(_BaseColor).rgb;
 #ifdef _DETAIL_MAP_IDX
 	
-	// Goal: we want the detail albedo map to be able to darken down to black and brighten up to white the surface albedo.
-	// The scale control the speed of the gradient. We simply remap detailAlbedo from [0..1] to [-1..1] then perform a lerp to black or white
-	// with a factor based on speed.
+    // Goal: we want the detail albedo map to be able to darken down to black and brighten up to white the surface albedo.
+    // The scale control the speed of the gradient. We simply remap detailAlbedo from [0..1] to [-1..1] then perform a lerp to black or white
+    // with a factor based on speed.
-	float albedoDetailSpeed = saturate(abs(detailAlbedo) * ADD_IDX(_DetailAlbedoScale));
-	float3 baseColorOverlay = lerp(sqrt(surfaceData.baseColor), (detailAlbedo < 0.0) ? float3(0.0, 0.0, 0.0) : float3(1.0, 1.0, 1.0), albedoDetailSpeed * albedoDetailSpeed);
-	baseColorOverlay *= baseColorOverlay;							   
+    float albedoDetailSpeed = saturate(abs(detailAlbedo) * ADD_IDX(_DetailAlbedoScale));
+    float3 baseColorOverlay = lerp(sqrt(surfaceData.baseColor), (detailAlbedo < 0.0) ? float3(0.0, 0.0, 0.0) : float3(1.0, 1.0, 1.0), albedoDetailSpeed * albedoDetailSpeed);
+    baseColorOverlay *= baseColorOverlay;							   
     // Lerp with details mask
     surfaceData.baseColor = lerp(surfaceData.baseColor, saturate(baseColorOverlay), detailMask);
 #endif
 #ifdef _DETAIL_MAP_IDX
     // See comment for baseColorOverlay
     float smoothnessDetailSpeed = saturate(abs(detailSmoothness) * ADD_IDX(_DetailSmoothnessScale));
-	float smoothnessOverlay = lerp(surfaceData.perceptualSmoothness, (detailSmoothness < 0.0) ? 0.0 : 1.0, smoothnessDetailSpeed);
+    float smoothnessOverlay = lerp(surfaceData.perceptualSmoothness, (detailSmoothness < 0.0) ? 0.0 : 1.0, smoothnessDetailSpeed);
     // Lerp with details mask
     surfaceData.perceptualSmoothness = lerp(surfaceData.perceptualSmoothness, saturate(smoothnessOverlay), detailMask);
 #endif

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/MaterialEvaluation.hlsl

     float3 indirectSpecularOcclusion;
 };
 
-void GetScreenSpaceAmbientOcclusion(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, out AmbientOcclusionFactor aoFactor)
+// Get screen space ambient occlusion only:
+float GetScreenSpaceDiffuseOcclusion(float2 positionSS)
-
-    // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
+     // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
-    // Ambient occlusion use for direct lighting (directional, punctual, area)
-    float directAmbientOcclusion = lerp(1.0, indirectAmbientOcclusion, _AmbientOcclusionParam.w);
-    float directAmbientOcclusion = 1.0;
+    return indirectAmbientOcclusion;
+}
+
+void GetScreenSpaceAmbientOcclusion(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, out AmbientOcclusionFactor aoFactor)
+{
+    float indirectAmbientOcclusion = GetScreenSpaceDiffuseOcclusion(positionSS);
+    float directAmbientOcclusion = lerp(1.0, indirectAmbientOcclusion, _AmbientOcclusionParam.w);
 
     float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
     float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
     aoFactor.directAmbientOcclusion = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), directAmbientOcclusion);
 }
 
+// Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the diffuseColor)
-    // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the diffuseColor)
-    // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
-    // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
-    // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
-
-    // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
-#ifndef _SURFACE_TYPE_TRANSPARENT
-    float indirectAmbientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, positionSS).x;
-    // Ambient occlusion use for direct lighting (directional, punctual, area)
+    float indirectAmbientOcclusion = GetScreenSpaceDiffuseOcclusion(positionSS);
-#else
-    float indirectAmbientOcclusion = 1.0;
-    float directAmbientOcclusion = 1.0;
-#endif
 
     float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
     float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
 
 void ApplyAmbientOcclusionFactor(AmbientOcclusionFactor aoFactor, inout BuiltinData builtinData, inout AggregateLighting lighting)
 {
-    // Note: in case of deferred Lit, builtinData.bakeDiffuseLighting contain indirect diffuse * surfaceData.ambientOcclusion + emissive,
-    // so emissive is affected by SSAO and we get a double darkening from SSAO and from AO which is incorrect but we accept the tradeoff
+    // Note: In case of deferred Lit, builtinData.bakeDiffuseLighting contains indirect diffuse * surfaceData.ambientOcclusion + emissive,
+    // so SSAO is multiplied by emissive which is wrong.
+    // Also, we have double occlusion for diffuse lighting since it already had precomputed AO (aka "FromData") applied
+    // (the * surfaceData.ambientOcclusion above)
+    // This is a tradeoff to avoid storing the precomputed (from data) AO in the GBuffer.
+    // (This is also why GetScreenSpaceAmbientOcclusion*() is effectively called with AOFromData = 1.0 in Lit:PostEvaluateBSDF() in the 
+    // deferred case since DecodeFromGBuffer will init bsdfData.ambientOcclusion to 1.0 and we will only have SSAO in the aoFactor here)
     builtinData.bakeDiffuseLighting *= aoFactor.indirectAmbientOcclusion;
     lighting.indirect.specularReflected *= aoFactor.indirectSpecularOcclusion;
     lighting.direct.diffuse *= aoFactor.directAmbientOcclusion;

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/HDRenderPipeline.cs

 
         public void ApplyDebugDisplaySettings(HDCamera hdCamera, CommandBuffer cmd)
         {
+            // See ShaderPassForward.hlsl: for forward shaders, if DEBUG_DISPLAY is enabled and no DebugLightingMode or DebugMipMapMod 
+            // modes have been set, lighting is automatically skipped (To avoid some crashed due to lighting RT not set on console).
+            // However debug mode like colorPickerModes and false color don't need DEBUG_DISPLAY and must work with the lighting.
+            // So we will enabled DEBUG_DISPLAY independently
+
+            // Enable globally the keyword DEBUG_DISPLAY on shader that support it with multicompile
+            CoreUtils.SetKeyword(cmd, "DEBUG_DISPLAY", m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled());
+
-                // enable globally the keyword DEBUG_DISPLAY on shader that support it with multicompile
-                cmd.EnableShaderKeyword("DEBUG_DISPLAY");
-
                 // This is for texture streaming
                 m_CurrentDebugDisplaySettings.UpdateMaterials();
 
 
                 // The DebugNeedsExposure test allows us to set a neutral value if exposure is not needed. This way we don't need to make various tests inside shaders but only in this function.
                 cmd.SetGlobalFloat(HDShaderIDs._DebugExposure, m_CurrentDebugDisplaySettings.DebugNeedsExposure() ? lightingDebugSettings.debugExposure : 0.0f);
-            }
-            else
-            {
-                // TODO: Be sure that if there is no change in the state of this keyword, it doesn't imply any work on CPU side! else we will need to save the sate somewher
-                cmd.DisableShaderKeyword("DEBUG_DISPLAY");
             }
         }
 

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.core/CoreRP/Editor/Lighting.meta

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

com.unity.render-pipelines.high-definition/HDRP/Editor/AssetProcessors/NormalMapFilteringTexturePostprocessor.cs

+using System;
+using UnityEngine;
+using System.IO;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    public class NormalMapFilteringTexturePostprocessor : AssetPostprocessor
+    {
+        // This class will process a normal map and add the value of average normal length to the blue or alpha channel
+        // The texture is saved as BC7.
+        // Tangent space normal map: BC7 RGB (normal xy - encoded variance)
+        // Object space normal map: BC7 RGBA (normal xyz - encoded variance)
+        static string s_Suffix = "_NF";
+        static string s_SuffixOS = "_OSNF"; // Suffix for object space case
+
+        bool IsAssetTaggedAsTangentSpaceNormalMap()
+        {
+            return Path.GetFileNameWithoutExtension(assetPath).EndsWith(s_Suffix, StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        bool IsAssetTaggedAsObjectSpaceNormalMap()
+        {
+            return Path.GetFileNameWithoutExtension(assetPath).EndsWith(s_SuffixOS, StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        void OnPreprocessTexture()
+        {
+            bool isNormalMapTangentSpace = IsAssetTaggedAsTangentSpaceNormalMap();
+            bool isNormalMapObjectSpace = isNormalMapTangentSpace ? false : IsAssetTaggedAsObjectSpaceNormalMap();
+
+            if (isNormalMapTangentSpace || isNormalMapObjectSpace)
+            {
+                // Make sure we don't convert as a normal map.
+                TextureImporter textureImporter = (TextureImporter)assetImporter;
+                textureImporter.convertToNormalmap = false;
+                //textureImporter.alphaSource = isNormalMapTangentSpace ? TextureImporterAlphaSource.None : TextureImporterAlphaSource.FromInput;
+                //bool inputHasAlphaChannel = textureImporter.DoesSourceTextureHaveAlpha();
+                // Hack:
+                // We need Unity to create an alpha channel when using object space normal maps!
+                // If it doesn't find one in input, and we set TextureImporterAlphaSource.FromInput, it will ignore our alpha values we
+                // set with SetPixels in OnPostProcess, even if the Texture2D format is eg RGBA.
+                // So here, we force it to create a dummy one in all cases (from gray scale)
+                textureImporter.alphaSource = isNormalMapTangentSpace ? TextureImporterAlphaSource.None : TextureImporterAlphaSource.FromGrayScale;
+                textureImporter.alphaIsTransparency = false;
+                textureImporter.mipmapEnabled = true;
+                textureImporter.textureCompression = TextureImporterCompression.CompressedHQ; // This is BC7 for Mac/PC
+                //textureImporter.textureCompression = TextureImporterCompression.Uncompressed;
+                // We can also force a format like TextureImporterFormat.BC6H or TextureImporterFormat.BC7:
+                var settings = textureImporter.GetPlatformTextureSettings("Standalone");
+                settings.format = TextureImporterFormat.BC7;
+                settings.overridden = true;
+                textureImporter.SetPlatformTextureSettings(settings);
+                textureImporter.isReadable = true;
+                // ...works without, but Unity doc says to set it if we need read access during OnPostProcess:
+                // https://docs.unity3d.com/ScriptReference/AssetPostprocessor.OnPostprocessTexture.html
+#pragma warning disable 618 // remove obsolete warning for this one
+                textureImporter.linearTexture = true; // Says deprecated but won't work without it.
+#pragma warning restore 618
+                textureImporter.sRGBTexture = false;  // But we're setting the new property just in case it changes later...
+            }
+        }
+
+        private static Color GetColor(Color[] source, int x, int y, int width, int height)
+        {
+            x = (x + width) % width; // for NPOT textures
+            y = (y + height) % height;
+
+            int index = y * width + x;
+            var c = source[index];
+
+            return c;
+        }
+
+        private static Vector3 GetNormal(Color[] source, int x, int y, int width, int height)
+        {
+            Vector3 n = (Vector4)GetColor(source, x, y, width, height);
+            n = 2.0f * n - Vector3.one;
+            n.Normalize();
+
+            return n;
+        }
+
+        private static Vector3 GetAverageNormal(Color[] source, int x, int y, int width, int height, int texelFootprintW, int texelFootprintH)
+        {
+            Vector3 averageNormal = new Vector3(0, 0, 0);
+
+            // Calculate the average color over the texel footprint.
+            for (int i = 0; i < texelFootprintH; ++i)
+            {
+                for (int j = 0; j < texelFootprintW; ++j)
+                {
+                    averageNormal += GetNormal(source, x + j, y + i, width, height);
+                }
+            }
+
+            averageNormal /= (texelFootprintW * texelFootprintH);
+
+            return averageNormal;
+        }
+
+        // Converts averageNormalLength to variance and
+        // thresholds and remaps variance from [0, highestVarianceAllowed] to [0, 1]
+        private static float GetEncodedVariance(float averageNormalLength)
+        {
+            // Caution: This constant must be in sync with CommonMaterial.hlsl #define NORMALMAP_HIGHEST_VARIANCE
+            const float highestVarianceAllowed = 0.03125f; // 0.25 * 0.25 / 2 = 0.0625 / 2 = 0.03125;
+
+            // To decide to store or not the averageNormalLength directly we need to consider:
+            //
+            // 1) useful range vs block compression and bit encoding of that range,
+            // 2) the possibly nonlinear conversion to variance,
+            // 3) computation in the shader.
+            //
+            // For 2) we need something that can be linearly filtered by the hardware as much as possible.
+            // Averages of length(average normal) are obviously not equal to length( of averages of normal)
+            // (that's the point of normal map inferred-NDF filtering vs just using mip-mapping hardware on normal maps),
+            // and the formula to get to variance via the vMF lobe fit is also quite nonlinear, although not
+            // everywhere. We show below that the most useful part of this fit (near the 1.0 end of the length
+            // of the average normal) is linear and so if we would store and filter averageNormalLength anyway
+            // but limit our range to that part, we could just store and filter directly the variance in that
+            // range too. (Note though that moments are linearly filterable cf LEAN, LEADR).
+            // For 1), compression can further compound artifacts too so we need to consider the useful range.
+            //
+            // We recall:
+            //
+            // Ref: Frequency Domain Normal Map Filtering - http://www.cs.columbia.edu/cg/normalmap/normalmap.pdf
+            // (equation 21)
+            // The relationship between between the standard deviation of a Gaussian distribution and
+            // the roughness parameter of a Beckmann distribution.is roughness^2 = 2 variance
+            // Ref: Filtering Distributions of Normals for Shading Antialiasing, equation just after (14).
+            // Relationship between gaussian lobe and vMF lobe is 2 * variance = 1 / (2 * kappa) = roughness^2
+            // (Equation 36 of  Normal map filtering based on The Order : 1886 SIGGRAPH course notes implementation).
+            //
+            // So to get variance we must use variance = 1 / (4 * kappa)
+            // where 
+            // kappa = (averageNormalLength*(3.0f - averageNormalLengthSquared)) / (1.0f - averageNormalLengthSquared);
+            //
+            float averageNormalLengthSquared = averageNormalLength * averageNormalLength;
+            float variance = 0.0f;
+            if (averageNormalLengthSquared < 1.0f)
+            {
+                float kappa = (averageNormalLength * (3.0f - averageNormalLengthSquared)) / (1.0f - averageNormalLengthSquared);
+                variance = 1.0f / (4.0f * kappa);
+            }
+
+            // The variance as a function of (averageNormalLength) is quite steep near 0 length, and 
+            // from about averageNormalLength = 0.376, variance stays under 0.2, and
+            // from about averageNormalLength = 0.603, variance stays under 0.1, and goes to 0 quite
+            // linearly as averageNormalLength goes to 1 with a slope of -1/4
+            // http://www.wolframalpha.com/input/?i=y(x)+:%3D+(1+-+x*x)%2F(4*(3x+-+x*x*x));+x+from+0+to+1
+
+            // Remember we do "+ min(2.0 * variance, threshold * threshold)" in NormalFiltering of CommonMaterial.hlsl
+            // to effectively limit the added_roughness^2
+            // when doing normal map filtering by modifying underlying BSDF roughness.
+            //
+            // An added variance of 0.1 gives an increase of roughness = sqrt(2 * 0.1) = 0.447, which is a huge increase already.
+            // An added variance of 0.03125 gives an increase of roughness = sqrt(2 * 0.03125) = 0.25, which still a lot
+            //
+            // Also remember that we use a user specified threshold to effectively limit the added_roughness^2,
+            // as shown above with + min(2.0 * variance, threshold * threshold)).
+            // We consider the relationship between the considered range of useful added variance vs that threshold:
+            // We have
+            // 2*variance_max_allowed = roughness_threshold_max_allowed^2
+            // variance_max_allowed = 0.5 * roughness_threshold_max_allowed^2
+            //
+            // Let's say we think an increased roughness^2 of threshold * threshold = 0.250^2 is enough such
+            // that we will never set the threshold in the UI to anything higher than 0.250.
+            // We then have:
+            //
+            // (0.250)^2 = (2 * variance_max_allowed)
+            // variance_max_allowed = 0.25*0.25 / 2 = 0.0625/2 = 0.03125
+            // 0.03125 = (1-xx)/(4*(3*x-x*x*x)) where x is lowestAverageNormalLengthAllowed
+            // http://www.wolframalpha.com/input/?i=0.03125+%3D++(1+-+x*x)%2F(4*(3x+-+x*x*x));+solve+for+x+from+0+to+1
+            // which gives our constants:
+            //
+            // highestVarianceAllowed = 0.03125f
+            // lowestAverageNormalLengthAllowed = 0.8695f;
+            //
+            float encodedVariance = Math.Min(variance, highestVarianceAllowed) / highestVarianceAllowed;
+            return encodedVariance;
+        }
+
+        void OnPostprocessTexture(Texture2D texture)
+        {
+            bool isNormalMapTangentSpace = IsAssetTaggedAsTangentSpaceNormalMap();
+            bool isNormalMapObjectSpace = isNormalMapTangentSpace ? false : IsAssetTaggedAsObjectSpaceNormalMap();
+
+            if (isNormalMapTangentSpace || isNormalMapObjectSpace)
+            {
+                // Based on The Order : 1886 SIGGRAPH course notes implementation. Sample all normal map
+                // texels from the base mip level that are within the footprint of the current mipmap texel.
+                Color[] source = texture.GetPixels(0);
+                for (int m = 1; m < texture.mipmapCount; m++)
+                {
+                    Color[] c = texture.GetPixels(m);
+
+                    int mipWidth = Math.Max(1, texture.width >> m);
+                    int mipHeight = Math.Max(1, texture.height >> m);
+                    int texelFootprintW = texture.width / mipWidth;
+                    int texelFootprintH = texture.height / mipHeight;
+                    for (int y = 0; y < mipHeight; ++y)
+                    {
+                        for (int x = 0; x < mipWidth; ++x)
+                        {
+                            Vector3 averageNormal = GetAverageNormal(source, x * texelFootprintW, y * texelFootprintH,
+                                    texture.width, texture.height, texelFootprintW, texelFootprintH);
+
+                            int outputPosition = y * mipWidth + x;
+
+                            // Note: As an optimization we could check what is generated in the mipmap (as it is suppose to be the average already)
+                            // TODO: Do some test and see if it is equivalent, for now reprocess all normal from top mips.
+                            // Vector3 existingAverageNormal = (Vector4)c[outputPosition];
+                            // existingAverageNormal = 2.0f * existingAverageNormal - Vector3.one;
+
+                            // Clamp to avoid any issue (shouldn't be required but sanitizes the normal map if needed)
+                            // We will also write the custom data into the blue channel to streamline the unpacking
+                            // shader code to fetch a 2 channel normal in RG whether we use normal map filtering or not.
+                            float averageNormalLength = Math.Max(0.0f, Math.Min(1.0f, averageNormal.magnitude));
+                            float outputValue = GetEncodedVariance(averageNormalLength);
+
+                            // Finally, note that since we need to add custom data in a map channel, we can't use the Unity
+                            // importer UI settings TextureType == NormalMap, since it leaves channel control to Unity in
+                            // that case and will make it interpret the x,y,z input as the normal to compress (which it might
+                            // do eg in 2 channels BC5)
+                            //
+                            // We need to normalize the resulting average normal and store the x,y components in the
+                            // proper (n + 1)/2 range encoded values in the R,G channels:
+                            averageNormal.Normalize();
+                            c[outputPosition].r = (averageNormal.x + 1.0f) / 2.0f;
+                            c[outputPosition].g = (averageNormal.y + 1.0f) / 2.0f;
+                            if (isNormalMapTangentSpace)
+                            {
+                                c[outputPosition].b = outputValue;
+                                c[outputPosition].a = 1.0f;
+                            }
+                            else
+                            {
+                                // Object space normal map needs 3 channels
+                                c[outputPosition].b = (averageNormal.z + 1.0f) / 2.0f;
+                                c[outputPosition].a = outputValue;
+                            }
+                        }
+                    }
+
+                    texture.SetPixels(c, m);
+                }
+
+                // Now overwrite the first mip average normal channel - order is important as above we read the mip0
+                // For mip 0, set the normal length to 1.
+                {
+                    Color[] c = texture.GetPixels(0);
+                    float outputValue = GetEncodedVariance(1.0f);
+                    for (int i = 0; i < c.Length; i++)
+                    {
+                        if (isNormalMapTangentSpace)
+                        {
+                            c[i].b = outputValue;
+                            c[i].a = 1.0f;
+                        }
+                        else
+                        {
+                            c[i].a = outputValue;
+                        }
+                    }
+                    texture.SetPixels(c, 0);
+                }
+                // Compression will be apply after this.
+                texture.Apply(updateMipmaps: false, makeNoLongerReadable: true);
+            }
+        }
+    }
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/HDLightEditorUtilities.cs

+using System;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    public static class HDLightEditorUtilities
+    {
+        public static void DrawFrustumlightGizmo(Light frustumlight)
+        {
+            var additionalLightData = frustumlight.GetComponent<HDAdditionalLightData>();
+            if (additionalLightData == null)
+                return;
+
+            Matrix4x4 matrix = new Matrix4x4(frustumlight.transform.right, frustumlight.transform.up, frustumlight.transform.forward, frustumlight.transform.position);
+            Gizmos.matrix = matrix;
+            if (additionalLightData.spotLightShape == SpotLightShape.Pyramid)
+            {
+                CoreLightEditorUtilities.DrawLightPyramidFrustum(Vector3.zero, frustumlight.spotAngle, frustumlight.range, 0.0f, additionalLightData.aspectRatio);
+            }
+            else // Ortho frustum
+            {
+                //DrawLightOrthoFrustum(Vector3.zero, additionalLightData.shapeWidth, additionalLightData.shapeHeight, frustumlight.range, 0.0f);
+
+                Vector3 frustumCenter = new Vector3(0.0f, 0.0f, 0.5f * frustumlight.range);
+                Vector3 frustumsize = new Vector3(additionalLightData.shapeWidth, additionalLightData.shapeHeight, frustumlight.range);
+                Gizmos.DrawWireCube(frustumCenter, frustumsize);
+            }
+            Gizmos.matrix = Matrix4x4.identity;
+        }
+    }
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/HDLightEditorUtilities.cs.meta

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

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.core/CoreRP/Editor/Lighting/CoreLightEditorUtilities.cs

+using System;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    public static class CoreLightEditorUtilities
+    {
+        // Don't use Handles.Disc as it break the highlight of the gizmo axis, use our own draw disc function instead for gizmo
+        public static void DrawWireDisc(Quaternion q, Vector3 position, Vector3 axis, float radius)
+        {
+            Matrix4x4 rotation = Matrix4x4.TRS(Vector3.zero, q, Vector3.one);
+
+            Gizmos.color = Color.white;
+            float theta = 0.0f;
+            float x = radius * Mathf.Cos(theta);
+            float y = radius * Mathf.Sin(theta);
+            Vector3 pos = rotation * new Vector3(x, y, 0);
+            pos += position;
+            Vector3 newPos = pos;
+            Vector3 lastPos = pos;
+            for (theta = 0.1f; theta < 2.0f * Mathf.PI; theta += 0.1f)
+            {
+                x = radius * Mathf.Cos(theta);
+                y = radius * Mathf.Sin(theta);
+
+                newPos = rotation * new Vector3(x, y, 0);
+                newPos += position;
+                Gizmos.DrawLine(pos, newPos);
+                pos = newPos;
+            }
+            Gizmos.DrawLine(pos, lastPos);
+        }
+
+        public static void DrawSpotlightGizmo(Light spotlight, float innerSpotPercent, bool selected)
+        {
+            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
+
+            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+
+            var rangeDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.range;
+            var rangeDiscRadius = spotlight.range * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
+            var nearDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.shadowNearPlane;
+            var nearDiscRadius = spotlight.shadowNearPlane * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
+
+            //Draw Range disc
+            DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * rangeDiscDistance, spotlight.gameObject.transform.forward, rangeDiscRadius);
+            //Draw Lines
+
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
+
+            if (selected)
+            {
+                //Draw Range Arcs
+                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.right, vectorLineUp, spotlight.spotAngle, spotlight.range);
+                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.up, vectorLineLeft, spotlight.spotAngle, spotlight.range);
+                //Draw Near Plane Disc
+                if (spotlight.shadows != LightShadows.None)
+                    DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * nearDiscDistance, spotlight.gameObject.transform.forward, nearDiscRadius);
+
+                //Inner Cone
+                DrawInnerCone(spotlight, innerSpotPercent);
+            }
+        }
+
+        // innerSpotPercent - 0 to 1 value (percentage 0 - 100%)
+        public static void DrawInnerCone(Light spotlight, float innerSpotPercent)
+        {
+            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * innerSpotPercent * Mathf.Deg2Rad * 0.5f);
+
+            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+
+            //Draw Lines
+
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
+
+            var innerAngle = spotlight.spotAngle * innerSpotPercent;
+            if (innerAngle > 0)
+            {
+                var innerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * innerAngle * 0.5f) * spotlight.range;
+                var innerDiscRadius = spotlight.range * Mathf.Sin(innerAngle * Mathf.Deg2Rad * 0.5f);
+                //Draw Range disc
+                DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * innerDiscDistance, spotlight.gameObject.transform.forward, innerDiscRadius);
+            }
+        }
+
+        public static void DrawArealightGizmo(Light arealight)
+        {
+            var RectangleSize = new Vector3(arealight.areaSize.x, arealight.areaSize.y, 0);
+            // Remove scale for light, not take into account
+            var localToWorldMatrix = Matrix4x4.TRS(arealight.transform.position, arealight.transform.rotation, Vector3.one);
+            Gizmos.matrix = localToWorldMatrix;
+            Gizmos.DrawWireCube(Vector3.zero, RectangleSize);
+            Gizmos.matrix = Matrix4x4.identity;
+            Gizmos.DrawWireSphere(arealight.transform.position, arealight.range);
+        }
+
+        public static void DrawPointlightGizmo(Light pointlight, bool selected)
+        {
+            if (pointlight.shadows != LightShadows.None && selected) Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.shadowNearPlane);
+            Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.range);
+        }
+
+        // Same as Gizmo.DrawFrustum except that when aspect is below one, fov represent fovX instead of fovY
+        // Use to match our light frustum pyramid behavior
+        public static void DrawLightPyramidFrustum(Vector3 center, float fov, float maxRange, float minRange, float aspect)
+        {
+            fov = Mathf.Deg2Rad * fov * 0.5f;
+            float tanfov = Mathf.Tan(fov);
+            Vector3 farEnd = new Vector3(0, 0, maxRange);
+            Vector3 endSizeX;
+            Vector3 endSizeY;
+
+            if (aspect >= 1.0f)
+            {
+                endSizeX = new Vector3(maxRange * tanfov * aspect, 0, 0);
+                endSizeY = new Vector3(0, maxRange * tanfov, 0);
+            }
+            else
+            {
+                endSizeX = new Vector3(maxRange * tanfov, 0, 0);
+                endSizeY = new Vector3(0, maxRange * tanfov / aspect, 0);
+            }
+
+            Vector3 s1, s2, s3, s4;
+            Vector3 e1 = farEnd + endSizeX + endSizeY;
+            Vector3 e2 = farEnd - endSizeX + endSizeY;
+            Vector3 e3 = farEnd - endSizeX - endSizeY;
+            Vector3 e4 = farEnd + endSizeX - endSizeY;
+            if (minRange <= 0.0f)
+            {
+                s1 = s2 = s3 = s4 = center;
+            }
+            else
+            {
+                Vector3 startSizeX;
+                Vector3 startSizeY;
+                if (aspect >= 1.0f)
+                {
+                    startSizeX = new Vector3(minRange * tanfov * aspect, 0, 0);
+                    startSizeY = new Vector3(0, minRange * tanfov, 0);
+                }
+                else
+                {
+                    startSizeY = new Vector3(minRange * tanfov / aspect, 0, 0);
+                    startSizeX = new Vector3(0, minRange * tanfov, 0);
+                }
+                Vector3 startPoint = center;
+                s1 =    startPoint + startSizeX + startSizeY;
+                s2 =    startPoint - startSizeX + startSizeY;
+                s3 =    startPoint - startSizeX - startSizeY;
+                s4 =    startPoint + startSizeX - startSizeY;
+                Gizmos.DrawLine(s1, s2);
+                Gizmos.DrawLine(s2, s3);
+                Gizmos.DrawLine(s3, s4);
+                Gizmos.DrawLine(s4, s1);
+            }
+
+            Gizmos.DrawLine(e1, e2);
+            Gizmos.DrawLine(e2, e3);
+            Gizmos.DrawLine(e3, e4);
+            Gizmos.DrawLine(e4, e1);
+
+            Gizmos.DrawLine(s1, e1);
+            Gizmos.DrawLine(s2, e2);
+            Gizmos.DrawLine(s3, e3);
+            Gizmos.DrawLine(s4, e4);
+        }
+
+        public static void DrawLightOrthoFrustum(Vector3 center, float width, float height, float maxRange, float minRange)
+        {
+            Vector3 farEnd = new Vector3(0, 0, maxRange);
+            Vector3 endSizeX = new Vector3(width, 0, 0);
+            Vector3 endSizeY = new Vector3(0, height, 0);
+
+            Vector3 s1, s2, s3, s4;
+            Vector3 e1 = farEnd + endSizeX + endSizeY;
+            Vector3 e2 = farEnd - endSizeX + endSizeY;
+            Vector3 e3 = farEnd - endSizeX - endSizeY;
+            Vector3 e4 = farEnd + endSizeX - endSizeY;
+            if (minRange <= 0.0f)
+            {
+                s1 = s2 = s3 = s4 = center;
+            }
+            else
+            {
+                Vector3 startSizeX = new Vector3(width, 0, 0);
+                Vector3 startSizeY = new Vector3(0, height, 0);
+
+                Vector3 startPoint = center;
+                s1 =    startPoint + startSizeX + startSizeY;
+                s2 =    startPoint - startSizeX + startSizeY;
+                s3 =    startPoint - startSizeX - startSizeY;
+                s4 =    startPoint + startSizeX - startSizeY;
+                Gizmos.DrawLine(s1, s2);
+                Gizmos.DrawLine(s2, s3);
+                Gizmos.DrawLine(s3, s4);
+                Gizmos.DrawLine(s4, s1);
+            }
+
+            Gizmos.DrawLine(e1, e2);
+            Gizmos.DrawLine(e2, e3);
+            Gizmos.DrawLine(e3, e4);
+            Gizmos.DrawLine(e4, e1);
+
+            Gizmos.DrawLine(s1, e1);
+            Gizmos.DrawLine(s2, e2);
+            Gizmos.DrawLine(s3, e3);
+            Gizmos.DrawLine(s4, e4);
+        }
+
+        public static void DrawDirectionalLightGizmo(Light directionalLight)
+        {
+            var gizmoSize = 0.2f;
+            DrawWireDisc(directionalLight.transform.rotation, directionalLight.transform.position, directionalLight.gameObject.transform.forward, gizmoSize);
+            Gizmos.DrawLine(directionalLight.transform.position, directionalLight.transform.position + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * gizmoSize, directionalLight.transform.position + directionalLight.transform.up * gizmoSize + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * -gizmoSize, directionalLight.transform.position + directionalLight.transform.up * -gizmoSize + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * gizmoSize, directionalLight.transform.position + directionalLight.transform.right * gizmoSize + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * -gizmoSize, directionalLight.transform.position + directionalLight.transform.right * -gizmoSize + directionalLight.transform.forward);
+        }
+    }
+}

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);
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/AssetProcessors/NormalMapAverageLengthTexturePostprocessor.cs

-using System;
-using UnityEngine;
-using System.IO;
-
-namespace UnityEditor.Experimental.Rendering.HDPipeline
-{
-    public class NormalMapAverageLengthTexturePostprocessor : AssetPostprocessor
-    {
-        // This class will process a normal map and add the value of average normal length to the blue or alpha channel
-        // The texture is save as BC7.
-        // Tangent space normal map: BC7 RGB (normal xy - average normal length)
-        // Object space normal map: BC7 RGBA (normal xyz - average normal length)
-        static string s_Suffix = "_NA";
-        //static string s_SuffixOS = "_OSNA"; // Suffix for object space case - TODO
-
-        void OnPreprocessTexture()
-        {
-            // Any texture with _NA suffix will store average normal lenght in alpha
-            if (Path.GetFileNameWithoutExtension(assetPath).EndsWith(s_Suffix, StringComparison.InvariantCultureIgnoreCase))
-            {
-                // Make sure we don't convert as a normal map.
-                TextureImporter textureImporter = (TextureImporter)assetImporter;
-                textureImporter.convertToNormalmap = false;
-                textureImporter.alphaSource = TextureImporterAlphaSource.None;
-                textureImporter.mipmapEnabled = true;
-                textureImporter.textureCompression = TextureImporterCompression.CompressedHQ; // This is BC7 for Mac/PC
-
-#pragma warning disable 618 // remove obsolete warning for this one
-                textureImporter.linearTexture = true; // Says deprecated but won't work without it.
-#pragma warning restore 618
-                textureImporter.sRGBTexture = false;  // But we're setting the new property just in case it changes later...
-            }
-        }
-
-        private static Color GetColor(Color[] source, int x, int y, int width, int height)
-        {
-            x = (x + width) % width;
-            y = (y + height) % height;
-
-            int index = y * width + x;
-            var c = source[index];
-
-            return c;
-        }
-
-        private static Vector3 GetNormal(Color[] source, int x, int y, int width, int height)
-        {
-            Vector3 n = (Vector4)GetColor(source, x, y, width, height);
-            n = 2.0f * n - Vector3.one;
-            n.Normalize();
-
-            return n;
-        }
-
-        private static Vector3 GetAverageNormal(Color[] source, int x, int y, int width, int height, int texelFootprint)
-        {
-            Vector3 averageNormal = new Vector3(0, 0, 0);
-
-            // Calculate the average color over the texel footprint.
-            for (int i = 0; i < texelFootprint; ++i)
-            {
-                for (int j = 0; j < texelFootprint; ++j)
-                {
-                    averageNormal += GetNormal(source, x + i, y + j, width, height);
-                }
-            }
-
-            averageNormal /= (texelFootprint * texelFootprint);
-
-            return averageNormal;
-        }
-
-        void OnPostprocessTexture(Texture2D texture)
-        {
-            if (Path.GetFileNameWithoutExtension(assetPath).EndsWith(s_Suffix, StringComparison.InvariantCultureIgnoreCase))
-            {
-                // Based on The Order : 1886 SIGGRAPH course notes implementation. Sample all normal map
-                // texels from the base mip level that are within the footprint of the current mipmap texel.
-                Color[] source = texture.GetPixels(0);
-                for (int m = 1; m < texture.mipmapCount; m++)
-                {
-                    Color[] c = texture.GetPixels(m);
-
-                    int mipWidth = Math.Max(1, texture.width >> m);
-                    int mipHeight = Math.Max(1, texture.height >> m);
-
-                    for (int x = 0; x < mipWidth; ++x)
-                    {
-                        for (int y = 0; y < mipHeight; ++y)
-                        {
-                            int texelFootprint = 1 << m;
-                            Vector3 averageNormal = GetAverageNormal(source, x * texelFootprint, y * texelFootprint,
-                                    texture.width, texture.height, texelFootprint);
-
-                            // Store the normal length for the average normal.
-                            int outputPosition = y * mipWidth + x;
-
-                            // Clamp to avoid any issue (TODO: Check this)
-                            // Write into the blue channel
-                            float averageNormalLength = Math.Max(0.0f, Math.Min(1.0f, averageNormal.magnitude));
-
-                            c[outputPosition].b = averageNormalLength;
-                            c[outputPosition].a = 1.0f;
-                        }
-                    }
-
-                    texture.SetPixels(c, m);
-                }
-
-                // Now overwrite the first mip average normal channel - order is important as above we read the mip0
-                // For mip 0, set the normal length to 1.
-                {
-                    Color[] c = texture.GetPixels(0);
-                    for (int i = 0; i < c.Length; i++)
-                    {
-                        c[i].b = 1.0f;
-                        c[i].a = 1.0f;
-                    }
-                    texture.SetPixels(c, 0);
-                }
-            }
-        }
-    }
-}

com.unity.render-pipelines.high-definition/HDRP/Lighting/Light/HDLightEditorUtilities.cs

-#if UNITY_EDITOR
-using System;
-using System.Reflection;
-using UnityEditor;
-using UnityEngine;
-using UnityEngine.Experimental.Rendering.HDPipeline;
-#endif
-
-namespace UnityEditor.Experimental.Rendering.HDPipeline
-{
-#if UNITY_EDITOR
-    public static class HDLightEditorUtilities
-    {
-        // Don't use Handles.Disc as it break the highlight of the gizmo axis, use our own draw disc function instead for gizmo
-        public static void DrawWireDisc(Quaternion q, Vector3 position, Vector3 axis, float radius)
-        {
-            Matrix4x4 rotation = Matrix4x4.TRS(Vector3.zero, q, Vector3.one);
-
-            Gizmos.color = Color.white;
-            float theta = 0.0f;
-            float x = radius * Mathf.Cos(theta);
-            float y = radius * Mathf.Sin(theta);
-            Vector3 pos = rotation * new Vector3(x, y, 0);
-            pos += position;
-            Vector3 newPos = pos;
-            Vector3 lastPos = pos;
-            for (theta = 0.1f; theta < 2.0f * Mathf.PI; theta += 0.1f)
-            {
-                x = radius * Mathf.Cos(theta);
-                y = radius * Mathf.Sin(theta);
-
-                newPos = rotation * new Vector3(x, y, 0);
-                newPos += position;
-                Gizmos.DrawLine(pos, newPos);
-                pos = newPos;
-            }
-            Gizmos.DrawLine(pos, lastPos);
-        }
-
-        public static void DrawSpotlightGizmo(Light spotlight, bool selected)
-        {
-            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
-
-            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-
-            var rangeDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.range;
-            var rangeDiscRadius = spotlight.range * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
-            var nearDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.shadowNearPlane;
-            var nearDiscRadius = spotlight.shadowNearPlane * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
-
-            //Draw Range disc
-            DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * rangeDiscDistance, spotlight.gameObject.transform.forward, rangeDiscRadius);
-            //Draw Lines
-
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
-
-            if (selected)
-            {
-                //Draw Range Arcs
-                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.right, vectorLineUp, spotlight.spotAngle, spotlight.range);
-                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.up, vectorLineLeft, spotlight.spotAngle, spotlight.range);
-                //Draw Near Plane Disc
-                if (spotlight.shadows != LightShadows.None)
-                    DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * nearDiscDistance, spotlight.gameObject.transform.forward, nearDiscRadius);
-
-                //Inner Cone
-                var additionalLightData = spotlight.GetComponent<HDAdditionalLightData>();
-                DrawInnerCone(spotlight, additionalLightData);
-            }
-        }
-
-        public static void DrawInnerCone(Light spotlight, HDAdditionalLightData additionalLightData)
-        {
-            if (additionalLightData == null) return;
-
-            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * additionalLightData.m_InnerSpotPercent * 0.01f * Mathf.Deg2Rad * 0.5f);
-
-            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-
-            //Draw Lines
-
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
-
-            var innerAngle = spotlight.spotAngle * additionalLightData.GetInnerSpotPercent01();
-            if (innerAngle > 0)
-            {
-                var innerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * innerAngle * 0.5f) * spotlight.range;
-                var innerDiscRadius = spotlight.range * Mathf.Sin(innerAngle * Mathf.Deg2Rad * 0.5f);
-                //Draw Range disc
-                DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * innerDiscDistance, spotlight.gameObject.transform.forward, innerDiscRadius);
-            }
-        }
-
-        public static void DrawArealightGizmo(Light arealight)
-        {
-            var RectangleSize = new Vector3(arealight.areaSize.x, arealight.areaSize.y, 0);
-            // Remove scale for light, not take into account
-            var localToWorldMatrix = Matrix4x4.TRS(arealight.transform.position, arealight.transform.rotation, Vector3.one);
-            Gizmos.matrix = localToWorldMatrix;
-            Gizmos.DrawWireCube(Vector3.zero, RectangleSize);
-            Gizmos.matrix = Matrix4x4.identity;
-            Gizmos.DrawWireSphere(arealight.transform.position, arealight.range);
-        }
-
-        public static void DrawPointlightGizmo(Light pointlight, bool selected)
-        {
-            if (pointlight.shadows != LightShadows.None && selected) Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.shadowNearPlane);
-            Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.range);
-        }
-
-        public static void DrawSpherelightGizmo(Light spherelight)
-        {
-            var additionalLightData = spherelight.GetComponent<HDAdditionalLightData>();
-            if (additionalLightData == null) return;
-            Gizmos.DrawSphere(spherelight.transform.position, additionalLightData.shapeWidth);
-            if (spherelight.shadows != LightShadows.None) Gizmos.DrawWireSphere(spherelight.transform.position, spherelight.shadowNearPlane);
-            Gizmos.DrawWireSphere(spherelight.transform.position, spherelight.range);
-        }
-
-        // Same as Gizmo.DrawFrustum except that when aspect is below one, fov represent fovX instead of fovY
-        // Use to match our light frustum pyramid behavior
-        public static void DrawLightPyramidFrustum(Vector3 center, float fov, float maxRange, float minRange, float aspect)
-        {
-            fov = Mathf.Deg2Rad * fov * 0.5f;
-            float tanfov = Mathf.Tan(fov);
-            Vector3 farEnd = new Vector3(0, 0, maxRange);
-            Vector3 endSizeX;
-            Vector3 endSizeY;
-
-            if (aspect >= 1.0f)
-            {
-                endSizeX = new Vector3(maxRange * tanfov * aspect, 0, 0);
-                endSizeY = new Vector3(0, maxRange * tanfov, 0);
-            }
-            else
-            {
-                endSizeX = new Vector3(maxRange * tanfov, 0, 0);
-                endSizeY = new Vector3(0, maxRange * tanfov / aspect, 0);
-            }
-
-            Vector3 s1, s2, s3, s4;
-            Vector3 e1 = farEnd + endSizeX + endSizeY;
-            Vector3 e2 = farEnd - endSizeX + endSizeY;
-            Vector3 e3 = farEnd - endSizeX - endSizeY;
-            Vector3 e4 = farEnd + endSizeX - endSizeY;
-            if (minRange <= 0.0f)
-            {
-                s1 = s2 = s3 = s4 = center;
-            }
-            else
-            {
-                Vector3 startSizeX;
-                Vector3 startSizeY;
-                if (aspect >= 1.0f)
-                {
-                    startSizeX = new Vector3(minRange * tanfov * aspect, 0, 0);
-                    startSizeY = new Vector3(0, minRange * tanfov, 0);
-                }
-                else
-                {
-                    startSizeY = new Vector3(minRange * tanfov / aspect, 0, 0);
-                    startSizeX = new Vector3(0, minRange * tanfov, 0);
-                }
-                Vector3 startPoint = center;
-                s1 =    startPoint + startSizeX + startSizeY;
-                s2 =    startPoint - startSizeX + startSizeY;
-                s3 =    startPoint - startSizeX - startSizeY;
-                s4 =    startPoint + startSizeX - startSizeY;
-                Gizmos.DrawLine(s1, s2);
-                Gizmos.DrawLine(s2, s3);
-                Gizmos.DrawLine(s3, s4);
-                Gizmos.DrawLine(s4, s1);
-            }
-
-            Gizmos.DrawLine(e1, e2);
-            Gizmos.DrawLine(e2, e3);
-            Gizmos.DrawLine(e3, e4);
-            Gizmos.DrawLine(e4, e1);
-
-            Gizmos.DrawLine(s1, e1);
-            Gizmos.DrawLine(s2, e2);
-            Gizmos.DrawLine(s3, e3);
-            Gizmos.DrawLine(s4, e4);
-        }
-
-        public static void DrawLightOrthoFrustum(Vector3 center, float width, float height, float maxRange, float minRange)
-        {
-            Vector3 farEnd = new Vector3(0, 0, maxRange);
-            Vector3 endSizeX = new Vector3(width, 0, 0);
-            Vector3 endSizeY = new Vector3(0, height, 0);
-
-            Vector3 s1, s2, s3, s4;
-            Vector3 e1 = farEnd + endSizeX + endSizeY;
-            Vector3 e2 = farEnd - endSizeX + endSizeY;
-            Vector3 e3 = farEnd - endSizeX - endSizeY;
-            Vector3 e4 = farEnd + endSizeX - endSizeY;
-            if (minRange <= 0.0f)
-            {
-                s1 = s2 = s3 = s4 = center;
-            }
-            else
-            {
-                Vector3 startSizeX = new Vector3(width, 0, 0);
-                Vector3 startSizeY = new Vector3(0, height, 0);
-
-                Vector3 startPoint = center;
-                s1 =    startPoint + startSizeX + startSizeY;
-                s2 =    startPoint - startSizeX + startSizeY;
-                s3 =    startPoint - startSizeX - startSizeY;
-                s4 =    startPoint + startSizeX - startSizeY;
-                Gizmos.DrawLine(s1, s2);
-                Gizmos.DrawLine(s2, s3);
-                Gizmos.DrawLine(s3, s4);
-                Gizmos.DrawLine(s4, s1);
-            }
-
-            Gizmos.DrawLine(e1, e2);
-            Gizmos.DrawLine(e2, e3);
-            Gizmos.DrawLine(e3, e4);
-            Gizmos.DrawLine(e4, e1);
-
-            Gizmos.DrawLine(s1, e1);
-            Gizmos.DrawLine(s2, e2);
-            Gizmos.DrawLine(s3, e3);
-            Gizmos.DrawLine(s4, e4);
-        }
-
-        public static void DrawFrustumlightGizmo(Light frustumlight)
-        {
-            var additionalLightData = frustumlight.GetComponent<HDAdditionalLightData>();
-            if (additionalLightData == null) return;
-
-            Matrix4x4 matrix = new Matrix4x4(frustumlight.transform.right, frustumlight.transform.up, frustumlight.transform.forward, frustumlight.transform.position);
-            Gizmos.matrix = matrix;
-            if (additionalLightData.spotLightShape == SpotLightShape.Pyramid)
-            {
-                DrawLightPyramidFrustum(Vector3.zero, frustumlight.spotAngle, frustumlight.range, 0.0f, additionalLightData.aspectRatio);
-            }
-            else // Ortho frustum
-            {
-                //DrawLightOrthoFrustum(Vector3.zero, additionalLightData.shapeWidth, additionalLightData.shapeHeight, frustumlight.range, 0.0f);
-
-                Vector3 frustumCenter = new Vector3(0.0f, 0.0f, 0.5f * frustumlight.range);
-                Vector3 frustumsize = new Vector3(additionalLightData.shapeWidth, additionalLightData.shapeHeight, frustumlight.range);
-                Gizmos.DrawWireCube(frustumCenter, frustumsize);
-            }
-            Gizmos.matrix = Matrix4x4.identity;
-        }
-
-        public static void DrawDirectionalLightGizmo(Light directionalLight)
-        {
-            var gizmoSize = 0.2f;
-            DrawWireDisc(directionalLight.transform.rotation, directionalLight.transform.position, directionalLight.gameObject.transform.forward, gizmoSize);
-            Gizmos.DrawLine(directionalLight.transform.position, directionalLight.transform.position + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * gizmoSize, directionalLight.transform.position + directionalLight.transform.up * gizmoSize + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * -gizmoSize, directionalLight.transform.position + directionalLight.transform.up * -gizmoSize + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * gizmoSize, directionalLight.transform.position + directionalLight.transform.right * gizmoSize + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * -gizmoSize, directionalLight.transform.position + directionalLight.transform.right * -gizmoSize + directionalLight.transform.forward);
-        }
-
-        public static void DrawCross(Transform m_transform)
-        {
-            var gizmoSize = 0.25f;
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.forward * gizmoSize / m_transform.localScale.z));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.forward * -gizmoSize / m_transform.localScale.z));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * gizmoSize / m_transform.localScale.y));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * -gizmoSize / m_transform.localScale.y));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * gizmoSize / m_transform.localScale.x));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * -gizmoSize / m_transform.localScale.x));
-        }
-    }
-#endif
-}