HDRenderPipeline: First draft of 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/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)
         _PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
+        // 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 _VERTEX_DISPLACEMENT    
+    #pragma shader_feature _DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _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)
         _PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
+        // 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 _VERTEX_DISPLACEMENT
+    #pragma shader_feature _DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _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 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");
 
+            // 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 readonly string[] tessellationModeNames = Enum.GetNames(typeof(TessellationMode));
             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";
+
+        // 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)
         {
             ppdMaxSamples = FindProperty(kPpdMaxSamples, props);
             ppdLodThreshold = FindProperty(kPpdLodThreshold, 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);
             tessellationFactor = FindProperty(kTessellationFactor, 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);
 
             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--;
+            }
+
+            EditorGUI.indentLevel--;
+
             // Display tessellation option if it exist
             if (tessellationMode != null)
             {
                 // 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);
-
-                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, "_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, "_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
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
+        // 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 _VERTEX_DISPLACEMENT
+    #pragma shader_feature _DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _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

 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 _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 _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
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
 
+        // 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 _VERTEX_DISPLACEMENT
+    #pragma shader_feature _DISPLACEMENT_OBJECT_SCALE
+    #pragma shader_feature _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_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_VERTEX_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_VERTEX_COLOR (defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))) || defined(_VERTEX_WIND) || REQUIRE_VERTEX_COLOR_FOR_TESSELATION
+#define REQUIRE_NORMAL defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT)
-#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
 
         #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_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && (defined(_VERTEX_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT_PHONG)))
+#define REQUIRE_VERTEX_COLOR (defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))) || defined(_VERTEX_WIND) || REQUIRE_VERTEX_COLOR_FOR_TESSELATION
+#define REQUIRE_NORMAL 0 /* defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT) */
+
-#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 REQUIRE_UV_FOR_TESSELATION || 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 _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 _DISPLACEMENT_OBJECT_SCALE
     float3 objectScale;
 #endif
 };
     float4 interpolators5 : TEXCOORD2;
 #endif
 
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _DISPLACEMENT_OBJECT_SCALE
     float3 interpolators6 : TEXCOORD3;
 #endif
 };
 #ifdef VARYINGS_DS_NEED_COLOR
     output.interpolators5 = input.color;
 #endif
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _DISPLACEMENT_OBJECT_SCALE
     output.interpolators6 = input.objectScale;
 #endif
 
 #ifdef VARYINGS_DS_NEED_COLOR
     output.color = input.interpolators5;
 #endif
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _DISPLACEMENT_OBJECT_SCALE
     output.objectScale = input.interpolators6;
 #endif
     return output;
     TESSELLATION_INTERPOLATE_BARY(color, baryCoords);
 #endif
 
-#ifdef _TESSELLATION_OBJECT_SCALE
+#ifdef _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 _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 _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;