Merge pull request #433 from Unity-Technologies/Add-support-of-vertex-displacement

Add support of vertex displacement

ScriptableRenderPipeline/Core/ShaderLibrary/Wind.hlsl

 
 
 
-void ApplyWind( inout float3    worldPos,
-                inout float3    worldNormal,
-                float3          rootWP,
-                float           stiffness,
-                float           drag,
-                float           shiverDrag,
-                float           shiverDirectionality,
-                float           initialBend,
-                float           shiverMask,
-                float4          time)
+void ApplyWindDisplacement( inout float3    positionWS,
+                            float3          normalWS,
+                            float3          rootWP,
+                            float           stiffness,
+                            float           drag,
+                            float           shiverDrag,
+                            float           shiverDirectionality,
+                            float           initialBend,
+                            float           shiverMask,
+                            float4          time)
-    WindData wind = GetAnalyticalWind(worldPos, rootWP, drag, shiverDrag, initialBend, time);
+    WindData wind = GetAnalyticalWind(positionWS, rootWP, drag, shiverDrag, initialBend, time);
-    if(wind.Strength > 0.0f)
+    if (wind.Strength > 0.0f)
-        float att = AttenuateTrunk(distance(worldPos, rootWP), stiffness);
+        float att = AttenuateTrunk(distance(positionWS, rootWP), stiffness);
-        worldPos = Rotate(rootWP, worldPos, rotAxis, (wind.Strength) * 0.001 * att);
+        positionWS = Rotate(rootWP, positionWS, rotAxis, (wind.Strength) * 0.001 * att);
-        float3 shiverDirection = normalize(lerp(worldNormal, normalize(wind.Direction + wind.ShiverDirection), shiverDirectionality));
-        worldPos += wind.ShiverStrength * shiverDirection * shiverMask;
+        float3 shiverDirection = normalize(lerp(normalWS, normalize(wind.Direction + wind.ShiverDirection), shiverDirectionality));
+        positionWS += wind.ShiverStrength * shiverDirection * shiverMask;
     }
 
 }

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using System;
             None = 0,
             Tessellation = DebugViewGbuffer.BakeDiffuseLightingWithAlbedoPlusEmissive + 1,
             PerPixelDisplacement,
+            VertexDisplacement,
             DepthOffset,
             Lightmap,
         }

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl

 #define DEBUGVIEWPROPERTIES_NONE (0)
 #define DEBUGVIEWPROPERTIES_TESSELLATION (12)
 #define DEBUGVIEWPROPERTIES_PER_PIXEL_DISPLACEMENT (13)
-#define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (14)
-#define DEBUGVIEWPROPERTIES_LIGHTMAP (15)
+#define DEBUGVIEWPROPERTIES_VERTEX_DISPLACEMENT (14)
+#define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (15)
+#define DEBUGVIEWPROPERTIES_LIGHTMAP (16)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.FullScreenDebugMode:  static fields

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.hlsl

 #endif
             break;
 
+        case DEBUGVIEWPROPERTIES_VERTEX_DISPLACEMENT:
+#ifdef _VERTEX_DISPLACEMENT // Caution: This define is related to a shader features (But it may become a standard features for HD
+            result = float3(1.0, 0.0, 0.0);
+#else
+            result = float3(0.0, 0.0, 0.0);
+#endif
+            break;
+
         case DEBUGVIEWPROPERTIES_DEPTH_OFFSET:
 #ifdef _DEPTHOFFSET_ON  // Caution: This define is related to a shader features (But it may become a standard features for HD
             result = float3(1.0, 0.0, 0.0);

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
-        // Wind
-        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
-        _InitialBend("Initial Bend", float) = 1.0
-        _Stiffness("Stiffness", float) = 1.0
-        _Drag("Drag", float) = 1.0
-        _ShiverDrag("Shiver Drag", float) = 0.2
-        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
-
         [ToggleOff]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
 
         _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
         _PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15
         _PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5
+        [ToggleOff] _PerPixelDisplacementObjectScale("Per pixel displacement object scale", Float) = 1.0
+
+        // Displacement map
+        [ToggleOff] _EnableVertexDisplacement("Enable vertex displacement", Float) = 0.0
+        [ToggleOff] _VertexDisplacementObjectScale("Vertex displacement object scale", Float) = 1.0
+        [ToggleOff] _VertexDisplacementTilingScale("Vertex displacement tiling height scale", Float) = 1.0
+
+        // Wind
+        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
+        _InitialBend("Initial Bend", float) = 1.0
+        _Stiffness("Stiffness", float) = 1.0
+        _Drag("Drag", float) = 1.0
+        _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
+
         // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
         // value that exist to identify if the GI emission need to be enabled.
         // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT_OBJECT_SCALE    
+    #pragma shader_feature _VERTEX_DISPLACEMENT    
+    #pragma shader_feature _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT_TILING_SCALE
+    #pragma shader_feature _VERTEX_WIND
 
     #pragma shader_feature _LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE
     #pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK _LAYER_MAPPING_TRIPLANAR_BLENDMASK
     #pragma shader_feature _DENSITY_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
-    #pragma shader_feature _VERTEX_WIND
 
     #pragma shader_feature _ _BLENDMODE_LERP _BLENDMODE_ADD _BLENDMODE_SOFT_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
     // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
     #define SURFACE_GRADIENT
+    // This shader support vertex modification
+    #define HAVE_VERTEX_MODIFICATION
 
     //-------------------------------------------------------------------------------------
     // Include

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

 
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
-        // Wind
-        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
-        _InitialBend("Initial Bend", float) = 1.0
-        _Stiffness("Stiffness", float) = 1.0
-        _Drag("Drag", float) = 1.0
-        _ShiverDrag("Shiver Drag", float) = 0.2
-        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
-
         [ToggleOff]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
 
         _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
         _PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15
         _PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5
+        [ToggleOff] _PerPixelDisplacementObjectScale("Per pixel displacement object scale", Float) = 1.0
+
+        // Displacement map
+        [ToggleOff] _EnableVertexDisplacement("Enable vertex displacement", Float) = 0.0
+        [ToggleOff] _VertexDisplacementObjectScale("Vertex displacement object scale", Float) = 1.0
+        [ToggleOff] _VertexDisplacementTilingScale("Vertex displacement tiling height scale", Float) = 1.0
+
+        // Wind
+        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
+        _InitialBend("Initial Bend", float) = 1.0
+        _Stiffness("Stiffness", float) = 1.0
+        _Drag("Drag", float) = 1.0
+        _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
+
         // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
         // value that exist to identify if the GI emission need to be enabled.
         // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
         [HideInInspector] _UVDetailsMappingMask2("_UVDetailsMappingMask2", Color) = (1, 0, 0, 0)
         [HideInInspector] _UVDetailsMappingMask3("_UVDetailsMappingMask3", Color) = (1, 0, 0, 0)
 
-        // Tesselation specific
-        [Enum(Phong, 0, Displacement, 1, DisplacementPhong, 2)] _TessellationMode("Tessellation mode", Float) = 1
+        [HideInInspector] _ShowMaterialReferences("_ShowMaterialReferences", Float) = 0
+        [HideInInspector] _ShowLayer0("_ShowLayer0", Float) = 0
+        [HideInInspector] _ShowLayer1("_ShowLayer1", Float) = 0
+        [HideInInspector] _ShowLayer2("_ShowLayer2", Float) = 0
+        [HideInInspector] _ShowLayer3("_ShowLayer3", Float) = 0
+
+        // Tessellation specific
+        [Enum(None, 0, Phong, 1)] _TessellationMode("Tessellation mode", Float) = 0
         _TessellationFactor("Tessellation Factor", Range(0.0, 15.0)) = 4.0
         _TessellationFactorMinDistance("Tessellation start fading distance", Float) = 20.0
         _TessellationFactorMaxDistance("Tessellation end fading distance", Float) = 50.0
-        [ToggleOff] _TessellationObjectScale("Tessellation object scale", Float) = 0.0
-        [ToggleOff] _TessellationTilingScale("Tessellation tiling scale", Float) = 1.0
-
-        [HideInInspector] _ShowMaterialReferences("_ShowMaterialReferences", Float) = 0
-        [HideInInspector] _ShowLayer0("_ShowLayer0", Float) = 0
-        [HideInInspector] _ShowLayer1("_ShowLayer1", Float) = 0
-        [HideInInspector] _ShowLayer2("_ShowLayer2", Float) = 0
-        [HideInInspector] _ShowLayer3("_ShowLayer3", Float) = 0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    // Default is _TESSELLATION_PHONG
-    #pragma shader_feature _ _TESSELLATION_DISPLACEMENT _TESSELLATION_DISPLACEMENT_PHONG
-    #pragma shader_feature _TESSELLATION_OBJECT_SCALE
-    #pragma shader_feature _TESSELLATION_TILING_SCALE
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT
+    #pragma shader_feature _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT_TILING_SCALE
+    #pragma shader_feature _VERTEX_WIND
+    #pragma shader_feature _TESSELLATION_PHONG
 
     #pragma shader_feature _LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE
     #pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK _LAYER_MAPPING_TRIPLANAR_BLENDMASK
     #pragma shader_feature _DENSITY_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
-    #pragma shader_feature _VERTEX_WIND
 
     #pragma shader_feature _ _BLENDMODE_LERP _BLENDMODE_ADD _BLENDMODE_SOFT_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY
 
     #define TESSELLATION_ON
     // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
     #define SURFACE_GRADIENT
+    // This shader support vertex modification
+    #define HAVE_VERTEX_MODIFICATION
+    #define HAVE_TESSELLATION_MODIFICATION
 
     //-------------------------------------------------------------------------------------
     // Include

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

             public static GUIContent ppdMinSamplesText = new GUIContent("Minimum steps", "Minimum steps (texture sample) to use with per pixel displacement mapping");
             public static GUIContent ppdMaxSamplesText = new GUIContent("Maximum steps", "Maximum steps (texture sample) to use with per pixel displacement mapping");
             public static GUIContent ppdLodThresholdText = new GUIContent("Fading mip level start", "Starting heightmap mipmap lod number where the parallax occlusion mapping effect start to disappear");
+            public static GUIContent perPixelDisplacementObjectScaleText = new GUIContent("Lock with object scale", "Per Pixel displacement will take into account the tiling scale - Only work with uniform positive scale");            
+
+            // Vertex displacement
+            public static string vertexDisplacementText = "Vertex displacement";
+
+            public static GUIContent enableVertexDisplacementText = new GUIContent("Enable vertex displacement", "Use heightmap as a displacement map. Displacement map is use to move vertex position in local space");
+            public static GUIContent vertexDisplacementObjectScaleText = new GUIContent("Lock with object scale", "Vertex displacement will take into account the object scale - Only work with uniform positive scale");
+            public static GUIContent vertexDisplacementTilingScaleText = new GUIContent("Lock with heightmap tiling", "Vertex displacement will take into account the tiling scale - Only work with uniform positive scale");
 
             // Tessellation
             public static string tessellationModeText = "Tessellation Mode";
             public static GUIContent tessellationFactorTriangleSizeText = new GUIContent("Triangle size", "Desired screen space sized of triangle (in pixel). Smaller value mean smaller triangle.");
             public static GUIContent tessellationShapeFactorText = new GUIContent("Shape factor", "Strength of Phong tessellation shape (lerp factor)");
             public static GUIContent tessellationBackFaceCullEpsilonText = new GUIContent("Triangle culling Epsilon", "If -1.0 back face culling is enabled for tessellation, higher number mean more aggressive culling and better performance");
-            public static GUIContent tessellationObjectScaleText = new GUIContent("Lock with object scale", "Tessellation displacement will take into account the object scale - Only work with uniform positive scale");
-            public static GUIContent tessellationTilingScaleText = new GUIContent("Lock with heightmap tiling", "Tessellation displacement will take into account the tiling scale - Only work with uniform positive scale");
+
+            // Vertex animation
+            public static string vertexAnimation = "Vertex animation";
 
             // Wind
             public static GUIContent windText = new GUIContent("Enable Wind");
             public static GUIContent windShiverDragText = new GUIContent("Shiver Drag");
             public static GUIContent windShiverDirectionalityText = new GUIContent("Shiver Directionality");
-
-            public static string vertexAnimation = "Vertex Animation";
         }
 
         public enum DoubleSidedNormalMode
 
         public enum TessellationMode
         {
-            Phong,
-            Displacement,
-            DisplacementPhong,
+            None,
+            Phong
         }
 
         protected MaterialProperty doubleSidedNormalMode = null;
 
         protected const string     kStencilRef = "_StencilRef";
 
+        // Per pixel displacement params
+        protected MaterialProperty enablePerPixelDisplacement = null;
+        protected const string kEnablePerPixelDisplacement = "_EnablePerPixelDisplacement";
+        protected MaterialProperty ppdMinSamples = null;
+        protected const string kPpdMinSamples = "_PPDMinSamples";
+        protected MaterialProperty ppdMaxSamples = null;
+        protected const string kPpdMaxSamples = "_PPDMaxSamples";
+        protected MaterialProperty ppdLodThreshold = null;
+        protected const string kPpdLodThreshold = "_PPDLodThreshold";
+        protected MaterialProperty perPixelDisplacementObjectScale = null;
+        protected const string kPerPixelDisplacementObjectScale = "_PerPixelDisplacementObjectScale";
+
+        // Vertex displacement
+        protected MaterialProperty enableVertexDisplacement = null;
+        protected const string kEnableVertexDisplacement = "_EnableVertexDisplacement";
+        protected MaterialProperty vertexDisplacementObjectScale = null;
+        protected const string kVertexDisplacementObjectScale = "_VertexDisplacementObjectScale";
+        protected MaterialProperty vertexDisplacementTilingScale = null;
+        protected const string kVertexDisplacementTilingScale = "_VertexDisplacementTilingScale";
+
         // Wind
         protected MaterialProperty windEnable = null;
         protected const string kWindEnabled = "_EnableWind";
         protected MaterialProperty windShiverDirectionality = null;
         protected const string kWindShiverDirectionality = "_ShiverDirectionality";
 
-        // Per pixel displacement params
-        protected MaterialProperty enablePerPixelDisplacement = null;
-        protected const string kEnablePerPixelDisplacement = "_EnablePerPixelDisplacement";
-        protected MaterialProperty ppdMinSamples = null;
-        protected const string kPpdMinSamples = "_PPDMinSamples";
-        protected MaterialProperty ppdMaxSamples = null;
-        protected const string kPpdMaxSamples = "_PPDMaxSamples";
-        protected MaterialProperty ppdLodThreshold = null;
-        protected const string kPpdLodThreshold = "_PPDLodThreshold";
-
         // tessellation params
         protected MaterialProperty tessellationMode = null;
         protected const string kTessellationMode = "_TessellationMode";
         protected const string kTessellationShapeFactor = "_TessellationShapeFactor";
         protected MaterialProperty tessellationBackFaceCullEpsilon = null;
         protected const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon";
-        protected MaterialProperty tessellationObjectScale = null;
-        protected const string kTessellationObjectScale = "_TessellationObjectScale";
-        protected MaterialProperty tessellationTilingScale = null;
-        protected const string kTessellationTilingScale = "_TessellationTilingScale";
 
         protected override void FindBaseMaterialProperties(MaterialProperty[] props)
         {
             ppdMinSamples = FindProperty(kPpdMinSamples, props);
             ppdMaxSamples = FindProperty(kPpdMaxSamples, props);
             ppdLodThreshold = FindProperty(kPpdLodThreshold, props);
+            perPixelDisplacementObjectScale = FindProperty(kPerPixelDisplacementObjectScale, props);            
+
+            // vertex displacement
+            enableVertexDisplacement = FindProperty(kEnableVertexDisplacement, props);
+            vertexDisplacementObjectScale = FindProperty(kVertexDisplacementObjectScale, props);
+            vertexDisplacementTilingScale = FindProperty(kVertexDisplacementTilingScale, props);
 
             // tessellation specific, silent if not found
             tessellationMode = FindProperty(kTessellationMode, props, false);
             tessellationFactorTriangleSize = FindProperty(kTessellationFactorTriangleSize, props, false);
             tessellationShapeFactor = FindProperty(kTessellationShapeFactor, props, false);
             tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false);
-            tessellationObjectScale = FindProperty(kTessellationObjectScale, props, false);
-            tessellationTilingScale = FindProperty(kTessellationTilingScale, props, false);
 
             // Wind
             windEnable = FindProperty(kWindEnabled, props);
                 m_MaterialEditor.ShaderProperty(ppdMaxSamples, StylesBaseLit.ppdMaxSamplesText);
                 ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue);
                 m_MaterialEditor.ShaderProperty(ppdLodThreshold, StylesBaseLit.ppdLodThresholdText);
-                m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);
+                //m_MaterialEditor.ShaderProperty(perPixelDisplacementObjectScale, StylesBaseLit.perPixelDisplacementObjectScaleText);
+                m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);                
+                EditorGUI.indentLevel--;
+            }
+
+            EditorGUI.indentLevel--;
+
+            // Vertex displacement options
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(StylesBaseLit.vertexDisplacementText, EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+
+            m_MaterialEditor.ShaderProperty(enableVertexDisplacement, StylesBaseLit.enableVertexDisplacementText);
+            if (enableVertexDisplacement.floatValue > 0.0f)
+            {
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(vertexDisplacementObjectScale, StylesBaseLit.vertexDisplacementObjectScaleText);
+                m_MaterialEditor.ShaderProperty(vertexDisplacementTilingScale, StylesBaseLit.vertexDisplacementTilingScaleText);
                 EditorGUI.indentLevel--;
             }
 
                 // clamp min distance to be below max distance
                 tessellationFactorMinDistance.floatValue = Math.Min(tessellationFactorMaxDistance.floatValue, tessellationFactorMinDistance.floatValue);
                 m_MaterialEditor.ShaderProperty(tessellationFactorTriangleSize, StylesBaseLit.tessellationFactorTriangleSizeText);
-                if ((TessellationMode)tessellationMode.floatValue == TessellationMode.Phong ||
-                    (TessellationMode)tessellationMode.floatValue == TessellationMode.DisplacementPhong)
+                if ((TessellationMode)tessellationMode.floatValue == TessellationMode.Phong)
                 {
                     m_MaterialEditor.ShaderProperty(tessellationShapeFactor, StylesBaseLit.tessellationShapeFactorText);
                 }
                 }
-                m_MaterialEditor.ShaderProperty(tessellationObjectScale, StylesBaseLit.tessellationObjectScaleText);
-                m_MaterialEditor.ShaderProperty(tessellationTilingScale, StylesBaseLit.tessellationTilingScaleText);
                 EditorGUI.indentLevel--;
             }
         }
             bool enablePerPixelDisplacement = material.GetFloat(kEnablePerPixelDisplacement) > 0.0f;
             SetKeyword(material, "_PER_PIXEL_DISPLACEMENT", enablePerPixelDisplacement);
 
-            if (material.HasProperty(kTessellationMode))
-            {
-                TessellationMode tessMode = (TessellationMode)material.GetFloat(kTessellationMode);
+            bool perPixelDisplacementObjectScale = material.GetFloat(kPerPixelDisplacementObjectScale) > 0.0;
+            SetKeyword(material, "_PER_PIXEL_DISPLACEMENT_OBJECT_SCALE", perPixelDisplacementObjectScale && enablePerPixelDisplacement);
-                if (tessMode == TessellationMode.Phong)
-                {
-                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT");
-                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
-                }
-                else if (tessMode == TessellationMode.Displacement)
-                {
-                    material.EnableKeyword("_TESSELLATION_DISPLACEMENT");
-                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
-                }
-                else
-                {
-                    material.DisableKeyword("_TESSELLATION_DISPLACEMENT");
-                    material.EnableKeyword("_TESSELLATION_DISPLACEMENT_PHONG");
-                }
+            bool enableVertexDisplacement = material.GetFloat(kEnableVertexDisplacement) > 0.0f;
+            SetKeyword(material, "_VERTEX_DISPLACEMENT", enableVertexDisplacement);
-                bool tessellationObjectScaleEnable = material.GetFloat(kTessellationObjectScale) > 0.0;
-                SetKeyword(material, "_TESSELLATION_OBJECT_SCALE", tessellationObjectScaleEnable);
+            bool vertexDisplacementObjectScaleEnable = material.GetFloat(kVertexDisplacementObjectScale) > 0.0;
+            SetKeyword(material, "_VERTEX_DISPLACEMENT_OBJECT_SCALE", vertexDisplacementObjectScaleEnable && enableVertexDisplacement);
-                bool tessellationTilingScaleEnable = material.GetFloat(kTessellationTilingScale) > 0.0;
-                SetKeyword(material, "_TESSELLATION_TILING_SCALE", tessellationTilingScaleEnable);
-            }
+            bool vertexDisplacementTilingScaleEnable = material.GetFloat(kVertexDisplacementTilingScale) > 0.0;
+            SetKeyword(material, "_VERTEX_DISPLACEMENT_TILING_SCALE", vertexDisplacementTilingScaleEnable && enableVertexDisplacement);
+
+            if (material.HasProperty(kTessellationMode))
+            {
+                TessellationMode tessMode = (TessellationMode)material.GetFloat(kTessellationMode);
+                SetKeyword(material, "_TESSELLATION_PHONG", tessMode == TessellationMode.Phong);
+            }
         }
 
         static public void SetupBaseLitMaterialPass(Material material)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         _SpecularColor("SpecularColor", Color) = (1, 1, 1, 1)
         _SpecularColorMap("SpecularColorMap", 2D) = "white" {}
 
-        // Wind
-        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
-        _InitialBend("Initial Bend", float) = 1.0
-        _Stiffness("Stiffness", float) = 1.0
-        _Drag("Drag", float) = 1.0
-        _ShiverDrag("Shiver Drag", float) = 0.2
-        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
-
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         // Following options are for the GUI inspector and different from the input parameters above
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
         _PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15
         _PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5
+        [ToggleOff] _PerPixelDisplacementObjectScale("Per pixel displacement object scale", Float) = 1.0
+
+        // Displacement map
+        [ToggleOff] _EnableVertexDisplacement("Enable vertex displacement", Float) = 0.0
+        [ToggleOff] _VertexDisplacementObjectScale("Vertex displacement object scale", Float) = 1.0
+        [ToggleOff] _VertexDisplacementTilingScale("Vertex displacement tiling height scale", Float) = 1.0
+
+        // Wind
+        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
+        _InitialBend("Initial Bend", float) = 1.0
+        _Stiffness("Stiffness", float) = 1.0
+        _Drag("Drag", float) = 1.0
+        _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
+
         // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
         // value that exist to identify if the GI emission need to be enabled.
         // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT
+    #pragma shader_feature _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT_TILING_SCALE
+    #pragma shader_feature _VERTEX_WIND
 
     #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
     #pragma shader_feature _NORMALMAP_TANGENT_SPACE
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
-    #pragma shader_feature _VERTEX_WIND
 
     #pragma shader_feature _ _BLENDMODE_LERP _BLENDMODE_ADD _BLENDMODE_SOFT_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY
 
     #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
     // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
     #define SURFACE_GRADIENT
+    // This shader support vertex modification
+    #define HAVE_VERTEX_MODIFICATION
 
     //-------------------------------------------------------------------------------------
     // Include

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 
             // Note: The TBN is not normalize as it is based on mikkt. We should normalize it, but POM is always use on simple enough surfarce that mean it is not required (save 2 normalize). Tag: SURFACE_GRADIENT
             float3 viewDirTS = isPlanar ? float3(uvXZ, V.y) : TransformWorldToTangent(V, worldToTangent);
+
             NdotV = viewDirTS.z;
 
             int numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, viewDirTS.z);
 float ComputePerVertexDisplacement(LayerTexCoord layerTexCoord, float4 vertexColor, float lod)
 {
     float height = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap, sampler_HeightMap, layerTexCoord.base, lod).r - _HeightCenter) * _HeightAmplitude;
-    #ifdef _TESSELLATION_TILING_SCALE
+    #ifdef _VERTEX_DISPLACEMENT_TILING_SCALE
     // When we change the tiling, we have want to conserve the ratio with the displacement (and this is consistent with per pixel displacement)
     // IDEA: precompute the tiling scale? MOV-MUL vs MOV-MOV-MAX-RCP-MUL.
     float tilingScale = rcp(max(_BaseColorMap_ST.x, _BaseColorMap_ST.y));
                         input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
 }
 
-void ApplyTessellationTileScale(inout float height0, inout float height1, inout float height2, inout float height3)
+void ApplyDisplacementTileScale(inout float height0, inout float height1, inout float height2, inout float height3)
-#ifdef _TESSELLATION_TILING_SCALE
+#ifdef _VERTEX_DISPLACEMENT_TILING_SCALE
     float tileObjectScale = 1.0;
     #ifdef _LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE
     // Extract scaling from world transform
     float height1 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap1, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base1, lod).r - _HeightCenter1) * _HeightAmplitude1;
     float height2 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap2, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base2, lod).r - _HeightCenter2) * _HeightAmplitude2;
     float height3 = (SAMPLE_UVMAPPING_TEXTURE2D_LOD(_HeightMap3, SAMPLER_HEIGHTMAP_IDX, layerTexCoord.base3, lod).r - _HeightCenter3) * _HeightAmplitude3;
-    ApplyTessellationTileScale(height0, height1, height2, height3); // Only apply with per vertex displacement
+    ApplyDisplacementTileScale(height0, height1, height2, height3); // Only apply with per vertex displacement
     SetEnabledHeightByLayer(height0, height1, height2, height3);
 
     float4 resultBlendMasks = inputBlendMasks;
 
 #endif // #ifndef LAYERED_LIT_SHADER
 
-#ifdef TESSELLATION_ON
-#endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.hlsl

+float3 GetVertexDisplacement(float3 positionWS, float3 normalWS, float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 vertexColor, float3 objectScale)
+{
+    // This call will work for both LayeredLit and Lit shader
+    LayerTexCoord layerTexCoord;
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    GetLayerTexCoord(texCoord0, texCoord1, texCoord2, texCoord3, positionWS, normalWS, layerTexCoord);
+
+    // TODO: do this algorithm for lod fetching as lod not available in vertex/domain shader
+    // http://www.sebastiansylvan.com/post/the-problem-with-tessellation-in-directx-11/
+    float lod = 0.0;
+    float height = ComputePerVertexDisplacement(layerTexCoord, vertexColor, lod);
+    float3 displ = height * normalWS;
+
+    // Applying scaling of the object if requested
+    displ *= objectScale;
+
+    return displ;
+}
+
+void ApplyVertexModification(AttributesMesh input, float3 normalWS, float3 objectScale, inout float3 positionWS)
+{
+// If tessellation is enabled we apply displacement map after tessellation
+#if defined(_VERTEX_DISPLACEMENT) && !defined(TESSELLATION_ON)
+    positionWS += GetVertexDisplacement(positionWS, normalWS,
+    #ifdef ATTRIBUTES_NEED_TEXCOORD0
+        input.uv0,
+    #else
+        float2(0.0, 0.0),
+    #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD1
+        input.uv1,
+    #else
+        float2(0.0, 0.0),
+    #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD2
+        input.uv2,
+    #else
+        float2(0.0, 0.0),
+    #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD3
+        input.uv3,
+    #else
+        float2(0.0, 0.0),
+    #endif            
+    #ifdef ATTRIBUTES_NEED_COLOR
+        input.color,
+    #else
+        float4(0.0, 0.0, 0.0, 0.0),
+    #endif      
+        objectScale);
+#endif
+    
+#ifdef _VERTEX_WIND
+    float3 rootWP = mul(GetObjectToWorldMatrix(), float4(0, 0, 0, 1)).xyz;
+    ApplyWindDisplacement(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, input.color.a, _Time);
+#endif
+}
+
+#ifdef TESSELLATION_ON
+
 float4 GetTessellationFactors(float3 p0, float3 p1, float3 p2, float3 n0, float3 n1, float3 n2)
 {
     float maxDisplacement = GetMaxDisplacement();
 // y - 2->0 edge
 // z - 0->1 edge
 // w - inside tessellation factor
-float3 GetTessellationDisplacement(VaryingsMeshToDS input)
+void ApplyTessellationModification(VaryingsMeshToDS input, float3 normalWS, float3 objectScale, inout float3 positionWS)
-    // This call will work for both LayeredLit and Lit shader
-    LayerTexCoord layerTexCoord;
-    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
-    GetLayerTexCoord(
-#ifdef VARYINGS_DS_NEED_TEXCOORD0
+#if defined(_VERTEX_DISPLACEMENT)
+    positionWS += GetVertexDisplacement(positionWS, normalWS,
+    #ifdef VARYINGS_DS_NEED_TEXCOORD0
-#else
+    #else
-#endif
-#ifdef VARYINGS_DS_NEED_TEXCOORD1
+    #endif
+    #ifdef VARYINGS_DS_NEED_TEXCOORD1
-#else
+    #else
-#endif
-#ifdef VARYINGS_DS_NEED_TEXCOORD2
+    #endif
+    #ifdef VARYINGS_DS_NEED_TEXCOORD2
-#else
+    #else
-#endif
-#ifdef VARYINGS_DS_NEED_TEXCOORD3
+    #endif
+    #ifdef VARYINGS_DS_NEED_TEXCOORD3
-#else
+    #else
-#endif
-        input.positionWS,
-        input.normalWS,
-        layerTexCoord);
-
-    // http://www.sebastiansylvan.com/post/the-problem-with-tessellation-in-directx-11/
-    float lod = 0.0;
-    float4 vertexColor = float4(0.0, 0.0, 0.0, 0.0);
-#ifdef VARYINGS_DS_NEED_COLOR
-    vertexColor = input.color;
-#endif
-    float height = ComputePerVertexDisplacement(layerTexCoord, vertexColor, lod);
-    float3 displ = height * input.normalWS;
-
-        // Applying scaling of the object if requested
-#ifdef _TESSELLATION_OBJECT_SCALE
-    displ *= input.objectScale;
-#endif
+    #endif            
+    #ifdef VARYINGS_DS_NEED_COLOR
+        input.color,
+    #else
+        float4(0.0, 0.0, 0.0, 0.0),
+    #endif      
+        objectScale);
+#endif // _VERTEX_DISPLACEMENT
+}
-    return displ;
-}
+#endif // #ifdef TESSELLATION_ON

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         _SpecularColor("SpecularColor", Color) = (1, 1, 1, 1)
         _SpecularColorMap("SpecularColorMap", 2D) = "white" {}
 
-        // Wind
-        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
-        _InitialBend("Initial Bend", float) = 1.0
-        _Stiffness("Stiffness", float) = 1.0
-        _Drag("Drag", float) = 1.0
-        _ShiverDrag("Shiver Drag", float) = 0.2
-        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
-
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
 
         // Following options are for the GUI inspector and different from the input parameters above
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
         _PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15
         _PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5
+        [ToggleOff] _PerPixelDisplacementObjectScale("Per pixel displacement object scale", Float) = 1.0
+
+        // Displacement map
+        [ToggleOff] _EnableVertexDisplacement("Enable vertex displacement", Float) = 0.0
+        [ToggleOff] _VertexDisplacementObjectScale("Vertex displacement object scale", Float) = 1.0
+        [ToggleOff] _VertexDisplacementTilingScale("Vertex displacement tiling height scale", Float) = 1.0
+
+        // Wind
+        [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
+        _InitialBend("Initial Bend", float) = 1.0
+        _Stiffness("Stiffness", float) = 1.0
+        _Drag("Drag", float) = 1.0
+        _ShiverDrag("Shiver Drag", float) = 0.2
+        _ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5
+
         // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
         // value that exist to identify if the GI emission need to be enabled.
         // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
         // Tessellation specific
-        [Enum(Phong, 0, Displacement, 1, DisplacementPhong, 2)] _TessellationMode("Tessellation mode", Float) = 0
+        [Enum(None, 0, Phong, 1)] _TessellationMode("Tessellation mode", Float) = 0
         _TessellationFactor("Tessellation Factor", Range(0.0, 15.0)) = 4.0
         _TessellationFactorMinDistance("Tessellation start fading distance", Float) = 20.0
         _TessellationFactorMaxDistance("Tessellation end fading distance", Float) = 50.0
-        [ToggleOff] _TessellationObjectScale("Tessellation object scale", Float) = 0.0
-        [ToggleOff] _TessellationTilingScale("Tessellation tiling height scale", Float) = 1.0
          // TODO: Handle culling mode for backface culling
     }
 
     #pragma shader_feature _DEPTHOFFSET_ON
     #pragma shader_feature _DOUBLESIDED_ON
     #pragma shader_feature _PER_PIXEL_DISPLACEMENT
-    // Default is _TESSELLATION_PHONG
-    #pragma shader_feature _ _TESSELLATION_DISPLACEMENT _TESSELLATION_DISPLACEMENT_PHONG
-    #pragma shader_feature _TESSELLATION_OBJECT_SCALE
-    #pragma shader_feature _TESSELLATION_TILING_SCALE
+    #pragma shader_feature _PER_PIXEL_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT
+    #pragma shader_feature _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _VERTEX_DISPLACEMENT_TILING_SCALE
+    #pragma shader_feature _VERTEX_WIND
+    #pragma shader_feature _TESSELLATION_PHONG
 
     #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
     #pragma shader_feature _NORMALMAP_TANGENT_SPACE
     #pragma shader_feature _SUBSURFACE_RADIUS_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
-    #pragma shader_feature _VERTEX_WIND
 
     #pragma shader_feature _ _BLENDMODE_LERP _BLENDMODE_ADD _BLENDMODE_SOFT_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY
 
     #define TESSELLATION_ON
     // Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet
     #define SURFACE_GRADIENT
+    // This shader support vertex modification
+    #define HAVE_VERTEX_MODIFICATION
+    #define HAVE_TESSELLATION_MODIFICATION
 
     //-------------------------------------------------------------------------------------
     // Include

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitDepthPass.hlsl

 #endif
 
 // Attributes
-#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
-#define REQUIRE_VERTEX_COLOR_FOR_TESSELATION REQUIRE_UV_FOR_TESSELATION
+#define REQUIRE_NORMAL defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT)
+#define REQUIRE_VERTEX_COLOR (defined(_VERTEX_DISPLACEMENT) && defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))) || defined(_VERTEX_WIND)
-#if defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND)
+#if REQUIRE_NORMAL
-
-#ifdef _VERTEX_WIND
+#if REQUIRE_VERTEX_COLOR
 #define ATTRIBUTES_NEED_COLOR
 #endif
 
 // When UVX is present, we assume that UVX - 1 ... UV0 is present
 
-#if REQUIRE_UV_FOR_TESSELATION || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON)
+#if defined(_VERTEX_DISPLACEMENT) || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON)
 #define ATTRIBUTES_NEED_TEXCOORD0
     #ifdef LAYERED_LIT_SHADER
     #define ATTRIBUTES_NEED_TEXCOORD1
         #define ATTRIBUTES_NEED_TEXCOORD3
         #endif
     #endif
-#endif
-
-#if REQUIRE_VERTEX_COLOR_FOR_TESSELATION
-#define ATTRIBUTES_NEED_COLOR
 #endif
 
 // Varying - Use for pixel shader

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitMetaPass.hlsl

-#ifndef SHADERPASS
+#ifndef SHADERPASS
 #error Undefine_SHADERPASS
 #endif
 
 #define ATTRIBUTES_NEED_NORMAL
 #endif
 
-#if defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))
+#define REQUIRE_VERTEX_COLOR defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))
+
+#if REQUIRE_VERTEX_COLOR
 #define ATTRIBUTES_NEED_COLOR
 #endif
 
-#if defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))
+#if REQUIRE_VERTEX_COLOR
 #define VARYINGS_NEED_COLOR
 #endif
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitVelocityPass.hlsl

 // conflict with the normal in the semantic. This need to be fix! Also no per pixel displacement is possible either.
 
 // Attributes
-#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
-#define REQUIRE_VERTEX_COLOR_FOR_TESSELATION REQUIRE_UV_FOR_TESSELATION
-#define REQUIRE_TANGENT_TO_WORLD 0 /* (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT)) */
+#define REQUIRE_TANGENT_TO_WORLD 0 /*  (defined(_HEIGHTMAP) && defined(_PER_PIXEL_DISPLACEMENT)) */
+#define REQUIRE_NORMAL 0 /*  defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT) */
+#define REQUIRE_VERTEX_COLOR (defined(_VERTEX_DISPLACEMENT) && defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))) || defined(_VERTEX_WIND)
+
-#if defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND)
-// #define ATTRIBUTES_NEED_NORMAL - When reenable, think to also enable code in VertMesh.hlsl
+#if REQUIRE_NORMAL
+#define ATTRIBUTES_NEED_NORMAL
-
-#ifdef _VERTEX_WIND
+#if REQUIRE_VERTEX_COLOR
 #define ATTRIBUTES_NEED_COLOR
 #endif
 
 // When UVX is present, we assume that UVX - 1 ... UV0 is present
 
-#if defined(_ALPHATEST_ON)
+#if defined(_VERTEX_DISPLACEMENT) || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON)
 #define ATTRIBUTES_NEED_TEXCOORD0
     #ifdef LAYERED_LIT_SHADER
     #define ATTRIBUTES_NEED_TEXCOORD1
     #endif
 #endif
 
-#if REQUIRE_VERTEX_COLOR_FOR_TESSELATION
-#define ATTRIBUTES_NEED_COLOR
-#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 // Required to get view vector
 #define VARYINGS_NEED_TANGENT_TO_WORLD
 #endif
 

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/TessellationShare.hlsl

     VaryingsToDS varying = InterpolateWithBaryCoordsToDS(varying0, varying1, varying2, baryCoords);
 
     // We have Phong tessellation in all case where we don't have displacement only
-#ifndef _TESSELLATION_DISPLACEMENT
+#ifdef _TESSELLATION_PHONG
 
     float3 p0 = varying0.vmesh.positionWS;
     float3 p1 = varying1.vmesh.positionWS;
                                                     baryCoords, _TessellationShapeFactor);
 #endif
 
-#if defined(_TESSELLATION_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)
-    varying.vmesh.positionWS += GetTessellationDisplacement(varying.vmesh);
+#ifdef HAVE_TESSELLATION_MODIFICATION
+    // TODO: This should be an uniform for the object, this code should be remove (and is specific to Lit.shader) once we have it. - Workaround for now
+    // Extract scaling from world transform
+    #ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    float3 objectScale = varying.vmesh.objectScale; 
+    #else
+    float3 objectScale = float3(1.0, 1.0, 1.0);
+    #endif
+    ApplyTessellationModification(varying.vmesh, varying.vmesh.normalWS, objectScale, varying.vmesh.positionWS);
 #endif
 
     return VertTesselation(varying);

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VaryingMesh.hlsl

 #ifdef VARYINGS_DS_NEED_COLOR
     float4 color;
 #endif
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
     float3 objectScale;
 #endif
 };
     float4 interpolators5 : TEXCOORD2;
 #endif
 
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
     float3 interpolators6 : TEXCOORD3;
 #endif
 };
 #ifdef VARYINGS_DS_NEED_COLOR
     output.interpolators5 = input.color;
 #endif
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
     output.interpolators6 = input.objectScale;
 #endif
 
 #ifdef VARYINGS_DS_NEED_COLOR
     output.color = input.interpolators5;
 #endif
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
     output.objectScale = input.interpolators6;
 #endif
     return output;
     TESSELLATION_INTERPOLATE_BARY(color, baryCoords);
 #endif
 
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
     // objectScale doesn't change for the whole object.
     ouput.objectScale = input0.objectScale;
 #endif

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VertMesh.hlsl

     VaryingsMeshType output;
 
     float3 positionWS = TransformObjectToWorld(input.positionOS);
-#if defined(ATTRIBUTES_NEED_NORMAL)
+#ifdef ATTRIBUTES_NEED_NORMAL
+#else
+    float3 normalWS = float3(0.0, 0.0, 0.0); // We need this case to be able to compile ApplyVertexModification that doesn't use normal.
-    float4 tangentWS = float4(0.0, 0.0, 0.0, 0.0);
-    float4 vertexColor = float4(0.0, 0.0, 0.0, 0.0);
-#if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(VARYINGS_DS_NEED_TANGENT)
-    tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
+#ifdef ATTRIBUTES_NEED_TANGENT
+    float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
-#if defined(VARYINGS_NEED_COLOR) || defined(VARYINGS_DS_NEED_COLOR)
-    vertexColor = input.color;
+    // TODO: This should be an uniform for the object, this code should be remove (and is specific to Lit.shader) once we have it. - Workaround for now
+    // Extract scaling from world transform
+#ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    float3 objectScale;
+    float4x4 worldTransform = GetObjectToWorldMatrix();
+    objectScale.x = length(float3(worldTransform._m00, worldTransform._m01, worldTransform._m02));
+    objectScale.y = length(float3(worldTransform._m10, worldTransform._m11, worldTransform._m12));
+    objectScale.z = length(float3(worldTransform._m20, worldTransform._m21, worldTransform._m22));
+#else
+    float3 objectScale = float3(1.0, 1.0, 1.0);
+    // TODO: deal with camera center rendering and instancing (This is the reason why we always perform two  steps transform to clip space + instancing matrix)
+
-#if defined(_VERTEX_WIND) && (SHADERPASS != SHADERPASS_VELOCITY)
-    float3 rootWP = mul(GetObjectToWorldMatrix(), float4(0, 0, 0, 1)).xyz;
-    ApplyWind(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, input.color.a, _Time);
+#if defined(HAVE_VERTEX_MODIFICATION) && (SHADERPASS != SHADERPASS_VELOCITY)
+    ApplyVertexModification(input, normalWS, objectScale, positionWS);
 #endif
 
     positionWS = GetCameraRelativePositionWS(positionWS);
-    #ifdef _TESSELLATION_OBJECT_SCALE
-    // Extract scaling from world transform
-    float4x4 worldTransform = GetObjectToWorldMatrix();
-    output.objectScale.x = length(float3(worldTransform._m00, worldTransform._m01, worldTransform._m02));
-    output.objectScale.y = length(float3(worldTransform._m10, worldTransform._m11, worldTransform._m12));
-    output.objectScale.z = length(float3(worldTransform._m20, worldTransform._m21, worldTransform._m22));
+    #ifdef _VERTEX_DISPLACEMENT_OBJECT_SCALE
+    // TODO: This should be an uniform for the object, this code should be remove (and is specific to Lit.shader) once we have it. - Workaround for now
+    output.objectScale = objectScale;
-    // TODO: deal with camera center rendering and instancing (This is the reason why we always perform tow steps transform to clip space + instancing matrix)
     // TODO: TEMP: Velocity has a flow as it doens't have normal. This need to be fix. In the mean time, generate fix normal so compiler doesn't complain - When fix, think to also enable ATTRIBUTES_NEED_NORMAL in LitVelocityPass.hlsl
     #if SHADERPASS == SHADERPASS_VELOCITY
     output.normalWS = float3(0.0, 0.0, 1.0);
     output.tangentWS = tangentWS;
     #endif
 #else
-
-    // TODO deal with camera center rendering and instancing (This is the reason why we always perform tow steps transform to clip space + instancing matrix)
     #ifdef VARYINGS_NEED_POSITION_WS
     output.positionWS = positionWS;
     #endif
     output.texCoord3 = input.uv3;
 #endif
 #if defined(VARYINGS_NEED_COLOR) || defined(VARYINGS_DS_NEED_COLOR)
-    output.color = vertexColor;
+    output.color = input.color;
 #endif
 
     return output;