Merge branch 'master' into LightUnits

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

 
 // space at the end of the variable name
 // WS: world space
+// RWS: Camera-Relative world space. A space where the translation of the camera have already been substract in order to improve precision
 // VS: view space
 // OS: object space
 // CS: Homogenous clip spaces

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

         #endif
     UNITY_INSTANCING_BUFFER_END(unity_Builtins2)
 
+
-    #define UNITY_MATRIX_M     UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_ObjectToWorldArray)
+    #ifdef MODIFY_MATRIX_FOR_CAMERA_RELATIVE_RENDERING
+    #define UNITY_MATRIX_M  ApplyCameraTranslationToMatrix(UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_ObjectToWorldArray))
+    #else
+    #define UNITY_MATRIX_M  UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_ObjectToWorldArray)
+    #endif
-    #define UNITY_MATRIX_I_M     UNITY_ACCESS_INSTANCED_PROP(MERGE_UNITY_BUILTINS_INDEX(UNITY_WORLDTOOBJECTARRAY_CB), unity_WorldToObjectArray)
+    #ifdef MODIFY_MATRIX_FOR_CAMERA_RELATIVE_RENDERING
+    #define UNITY_MATRIX_I_M    ApplyCameraTranslationToInverseMatrix(UNITY_ACCESS_INSTANCED_PROP(MERGE_UNITY_BUILTINS_INDEX(UNITY_WORLDTOOBJECTARRAY_CB), unity_WorldToObjectArray))
+    #else
+    #define UNITY_MATRIX_I_M    UNITY_ACCESS_INSTANCED_PROP(MERGE_UNITY_BUILTINS_INDEX(UNITY_WORLDTOOBJECTARRAY_CB), unity_WorldToObjectArray)
+    #endif
 
 #else // UNITY_INSTANCING_ENABLED
 

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

 - Add contact shadows for punctual lights (in additional shadow settings), only one light is allowed to cast contact shadows at the same time and so at each frame a dominant light is choosed among all light with contact shadows enabled.
 - Add PCSS shadow filter support (from SRP Core)
 - Exposed shadow budget parameters in HDRP asset
+- Add an option to generate an emissive mesh for area lights (currently rectangle light only). The mesh fits the size, intensity and color of the light.
-- Change code in area light with LTC for Lit shader. Magnitude is now take from FGD texture instead of a separate texture.
+- Change code in area light with LTC for Lit shader. Magnitude is now take from FGD texture instead of a separate texture
+- Improve camera relative rendering: We now apply camera translation on the model matrix, so before the TransformObjectToWorld(). Note: unity_WorldToObject and unity_ObjectToWorld must never be used directly.
+- Rename positionWS to positionRWS (Camera relative world position) at a lot of places (mainly in interpolator and FragInputs). In case of custom shader user will be required to update their code. 
 
 ### Fixed
 - Fix contact shadows applied on transmission

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

             public readonly GUIContent shapeWidthBox = new GUIContent("Size X", "");
             public readonly GUIContent shapeHeightBox = new GUIContent("Size Y", "");
             public readonly GUIContent applyRangeAttenuation = new GUIContent("Apply Range Attenuation", "Allows disabling range attenuation. This is useful indoor (like a room) to avoid having to setup a large range for a light to get correct inverse square attenuation that may leak out of the indoor");
+            public readonly GUIContent displayAreaLightEmissiveMesh = new GUIContent("Display Emissive Mesh", "Generate an emissive mesh using the size, color and intensity of the area light");
 
             public readonly GUIContent shape = new GUIContent("Type", "Specifies the current type of light. Possible types are Directional, Spot, Point, Rectangle and Line lights.");
             public readonly GUIContent[] shapeNames;

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

 using System;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.Assertions;
 using UnityEngine.Experimental.Rendering;
             public SerializedProperty applyRangeAttenuation;
             public SerializedProperty volumetricDimmer;
             public SerializedProperty lightUnit;
+            public SerializedProperty displayAreaLightEmissiveMesh;
 
             // Editor stuff
             public SerializedProperty useOldInspector;
 
         // Used for UI only; the processing code must use LightTypeExtent and LightType
         LightShape m_LightShape;
+
+        HDAdditionalLightData[]     m_AdditionalLightDatas;
+        AdditionalShadowData[]      m_AdditionalShadowDatas;
+
+        // Used to detect if the scale have been changed via the transform component
+        Vector3 m_OldAreaLightSize;
+        bool m_UpdateAreaLightEmissiveMesh;
 
         protected override void OnEnable()
         {
-            var lightData = CoreEditorUtils.GetAdditionalData<HDAdditionalLightData>(targets, HDAdditionalLightData.InitDefaultHDAdditionalLightData);
-            var shadowData = CoreEditorUtils.GetAdditionalData<AdditionalShadowData>(targets, HDAdditionalShadowData.InitDefaultHDAdditionalShadowData);
-            m_SerializedAdditionalLightData = new SerializedObject(lightData);
-            m_SerializedAdditionalShadowData = new SerializedObject(shadowData);
+            m_AdditionalLightDatas = CoreEditorUtils.GetAdditionalData<HDAdditionalLightData>(targets, HDAdditionalLightData.InitDefaultHDAdditionalLightData);
+            m_AdditionalShadowDatas = CoreEditorUtils.GetAdditionalData<AdditionalShadowData>(targets, HDAdditionalShadowData.InitDefaultHDAdditionalShadowData);
+            m_SerializedAdditionalLightData = new SerializedObject(m_AdditionalLightDatas);
+            m_SerializedAdditionalShadowData = new SerializedObject(m_AdditionalShadowDatas);
 
             using (var o = new PropertyFetcher<HDAdditionalLightData>(m_SerializedAdditionalLightData))
                 m_AdditionalLightData = new SerializedLightData
                     lightDimmer = o.Find(x => x.lightDimmer),
                     volumetricDimmer = o.Find(x => x.volumetricDimmer),
                     lightUnit = o.Find(x => x.lightUnit),
+                    displayAreaLightEmissiveMesh = o.Find(x => x.displayAreaLightEmissiveMesh),
                     fadeDistance = o.Find(x => x.fadeDistance),
                     affectDiffuse = o.Find(x => x.affectDiffuse),
                     affectSpecular = o.Find(x => x.affectSpecular),
             CoreEditorUtils.DrawSplitter();
             EditorGUILayout.Space();
 
+            UpdateAreaLightEmissiveMeshSize();
+
+
+            if (m_UpdateAreaLightEmissiveMesh)
+                UpdateAreaLightEmissiveMesh();
         }
 
         void DrawFoldout(SerializedProperty foldoutProperty, string title, Action func)
             if (EditorGUI.EndChangeCheck())
             {
                 UpdateLightIntensityUnit();
+                m_UpdateAreaLightEmissiveMesh = true;
+                ((Light)target).SetLightDirty(); // Should be apply only to parameter that's affect GI, but make the code cleaner
             }
         }
 
                 m_AdditionalLightData.lightUnit.enumValueIndex = (int)LightUnit.Lumen;
         }
 
+        bool IsAreaLightShape(LightShape shape)
+        {
+            return shape == LightShape.Rectangle || shape == LightShape.Line;
+        }
+
+        void UpdateAreaLightEmissiveMesh()
+        {
+            foreach (var lightData in m_AdditionalLightDatas)
+            {
+                GameObject    lightGameObject = lightData.gameObject;
+                MeshRenderer  emissiveMeshRenderer = lightData.GetComponent<MeshRenderer>();
+                MeshFilter    emissiveMeshFilter = lightData.GetComponent<MeshFilter>();
+                Light         light = lightGameObject.GetComponent<Light>();
+
+                bool displayAreaLightEmissiveMesh = IsAreaLightShape(m_LightShape) && m_LightShape != LightShape.Line && m_AdditionalLightData.displayAreaLightEmissiveMesh.boolValue;
+
+                // Ensure that the emissive mesh components are here
+                if (displayAreaLightEmissiveMesh)
+                {
+                    if (emissiveMeshRenderer == null)
+                        emissiveMeshRenderer = lightGameObject.AddComponent<MeshRenderer>();
+                    if (emissiveMeshFilter == null)
+                        emissiveMeshFilter = lightGameObject.AddComponent<MeshFilter>();
+                }
+                else // Or remove them if the option is disabled
+                {
+                    if (emissiveMeshRenderer != null)
+                        DestroyImmediate(emissiveMeshRenderer);
+                    if (emissiveMeshFilter != null)
+                        DestroyImmediate(emissiveMeshFilter);
+                    
+                    // Skip to the next light
+                    continue;
+                }
+
+                float areaLightIntensity = 0.0f;
+
+                // Update Mesh emissive value
+                switch (m_LightShape)
+                {
+                    case LightShape.Rectangle:
+                        emissiveMeshFilter.mesh = HDEditorUtils.LoadAsset< Mesh >("RenderPipelineResources/Quad.FBX");
+                        lightGameObject.transform.localScale = new Vector3(lightData.shapeWidth, lightData.shapeHeight, 0);
+                        // Do the same conversion as for light intensity
+                        areaLightIntensity = LightUtils.ConvertRectLightLumenToLuminance(
+                            m_AdditionalLightData.intensity.floatValue,
+                            lightData.shapeWidth,
+                            lightData.shapeHeight);
+                        break;
+                    default:
+                        break;
+                }
+
+                if (emissiveMeshRenderer.sharedMaterial == null)
+                    emissiveMeshRenderer.material = new Material(Shader.Find("HDRenderPipeline/Unlit"));
+                
+                emissiveMeshRenderer.sharedMaterial.SetColor("_UnlitColor", Color.black);
+                // Note that we must use the light in linear RGB
+                emissiveMeshRenderer.sharedMaterial.SetColor("_EmissiveColor", light.color.linear * areaLightIntensity);
+            }
+        }
+
+        // This function updates the area light size when the local scale of the gameobject changes
+        void UpdateAreaLightEmissiveMeshSize()
+        {
+            // Early exit if the light type is not an area
+            if (!IsAreaLightShape(m_LightShape) || target == null || targets.Length > 1)
+                return ;
+            
+            Vector3 lightSize = ((Light)target).transform.localScale;
+            lightSize = Vector3.Max(Vector3.one * k_MinAreaWidth, lightSize);
+
+            if (lightSize == m_OldAreaLightSize)
+                return ;
+
+            switch (m_LightShape)
+            {
+                case LightShape.Rectangle:
+                    m_AdditionalLightData.shapeWidth.floatValue = lightSize.x;
+                    m_AdditionalLightData.shapeHeight.floatValue = lightSize.y;
+                    break;
+                default:
+                    break;
+            }
+
+            m_UpdateAreaLightEmissiveMesh = true;
+
+            m_OldAreaLightSize = lightSize;
+        }
+
         LightUnit LightIntensityUnitPopup(LightShape shape)
         {
             LightUnit     selectedLightUnit;
 
         void DrawLightSettings()
         {
+            EditorGUI.BeginChangeCheck();
+            if (EditorGUI.EndChangeCheck())
+                m_UpdateAreaLightEmissiveMesh = true;
+
+            EditorGUI.BeginChangeCheck();
 
             EditorGUILayout.BeginHorizontal();
             EditorGUILayout.PropertyField(m_AdditionalLightData.intensity, s_Styles.lightIntensity);
                     EditorGUILayout.PropertyField(m_AdditionalLightData.enableSpotReflector, s_Styles.enableSpotReflector);
             }
 
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_UpdateAreaLightEmissiveMesh = true;
+            }
+
             settings.DrawBounceIntensity();
 
             settings.DrawLightmapping();
             // No cookie with area light (maybe in future textured area light ?)
-            if (m_LightShape != LightShape.Rectangle && m_LightShape != LightShape.Line)
+            if (!IsAreaLightShape(m_LightShape))
             {
                 settings.DrawCookie();
 
                 EditorGUILayout.PropertyField(m_AdditionalLightData.volumetricDimmer, s_Styles.volumetricDimmer);
                 if (m_LightShape != LightShape.Directional)
                     EditorGUILayout.PropertyField(m_AdditionalLightData.applyRangeAttenuation, s_Styles.applyRangeAttenuation);
+
+                // Emissive mesh for area light only
+                if (IsAreaLightShape(m_LightShape))
+                {
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.displayAreaLightEmissiveMesh, s_Styles.displayAreaLightEmissiveMesh);
+                    if (EditorGUI.EndChangeCheck())
+                        m_UpdateAreaLightEmissiveMesh = true;
+                }
+
                 EditorGUI.indentLevel--;
             }
 

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

 
             public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)");
 
-            public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
             public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor");
             public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness scale factor");
             public static GUIContent smoothnessRemappingText = new GUIContent("Smoothness Remapping", "Smoothness remapping");

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/StackLit/BaseMaterialUI.cs

 
                 m_ChannelProperty = new ComboProperty(parent, propertyName + "Channel", "Channel", Enum.GetNames(typeof(Channel)), false);
 
-                m_RemapProperty = new Property(parent, constantPropertyName + "Remap", "Remapping", "Defines the range to remap/scale the values in texture", false);
-                m_InvertRemapProperty = new Property(parent, constantPropertyName + "RemapInverted", "Invert Remapping", "Whether the mapping values are inverted.", false);
+                m_RemapProperty = new Property(parent, propertyName + "Remap", "Remapping", "Defines the range to remap/scale the values in texture", false);
+                m_InvertRemapProperty = new Property(parent, propertyName + "RemapInverted", "Invert Remapping", "Whether the mapping values are inverted.", false);
             }
 
             public override void OnFindProperty(MaterialProperty[] props)

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/StackLit/StackLitUI.cs

         protected const string k_IridescenceMaskMap = "_IridescenceMaskMap";
         protected const string k_IridescenceMaskMapUV = "_IridescenceMaskMapUV";
 
+        // Details
+        protected const string k_EnableDetails = "_EnableDetails";
+        
+        protected const string k_DetailMask = "_DetailMask";
+        protected const string k_DetailMaskMap = "_DetailMaskMap";
+        protected const string k_DetailMaskMapUV = "_DetailMaskMapUV";
+
+        protected const string k_DetailSmoothness = "_DetailSmoothness";
+        protected const string k_DetailSmoothnessScale = "_DetailSmoothnessScale";
+        protected const string k_DetailSmoothnessMap = "_DetailSmoothnessMap";
+        protected const string k_DetailSmoothnessMapUV = "_DetailSmoothnessMapUV";
+
+        protected const string k_DetailNormalMap = "_DetailNormalMap";
+        protected const string k_DetailNormalMapUV = "_DetailNormalMapUV";
+        protected const string k_DetailNormalScale = "_DetailNormalScale";
+
         // Stencil is use to control lighting mode (regular, split lighting)
         protected const string kStencilRef = "_StencilRef";
         protected const string kStencilWriteMask = "_StencilWriteMask";
         private readonly GroupProperty _baseMaterialProperties = null;
         private readonly GroupProperty _materialProperties = null;
 
+        private Property EnableDetails;
-        private Property EnableDualSpecularLobe;
+        private Property EnableDualSpecularLobe;        
         private Property EnableIridescence;
 
         private Property EnableGeometricNormalFiltering;
             });
 
             //
+            EnableDetails = new Property(this, k_EnableDetails, "Enable Details", "Enable Detail", true);
             EnableSSS = new Property(this, k_EnableSubsurfaceScattering, "Enable Subsurface Scattering", "Enable Subsurface Scattering", true);
             EnableTransmission = new Property(this, k_EnableTransmission, "Enable Transmission", "Enable Transmission", true);
             EnableCoat = new Property(this, k_EnableCoat, "Enable Coat", "Enable coat layer with true vertical physically based BSDF mixing", true);
             {
                 new GroupProperty(this, "_MaterialFeatures", "Material Features", new BaseProperty[]
                 {
+                    EnableDetails,
                     EnableDualSpecularLobe,
                     EnableAnisotropy,
                     EnableCoat,
                     new TextureProperty(this, k_NormalMap, k_NormalScale, "Normal", "Normal Map", true, false, true),
                     new TextureProperty(this, k_AmbientOcclusionMap, k_AmbientOcclusion, "AmbientOcclusion", "AmbientOcclusion Map", false, false),
                 }),
+
+                new GroupProperty(this, "_Details", "Details", new BaseProperty[]
+                {
+                    new TextureProperty(this, k_DetailMaskMap, "", "Detail Mask Map", "Detail Mask Map", false, false),
+                    new TextureProperty(this, k_DetailNormalMap, k_DetailNormalScale, "Detail Normal Map", "Detail Normal Map Scale", true, false, true),
+                    new TextureProperty(this, k_DetailSmoothnessMap, k_DetailSmoothnessScale, "Detail Smoothness", "Detail Smoothness", true, false),
+                }, _ => EnableDetails.BoolValue == true),
 
                 new GroupProperty(this, "_DualSpecularLobe", "Dual Specular Lobe", new BaseProperty[]
                 {
             // TODO: Caution this can generate a lot of garbage collection call ?
             string useMapPropertyName = basePropertyName + "UseMap";
             string mapPropertyName = basePropertyName + "Map";
-            string remapPropertyName = basePropertyName + "Remap";
-            string invertPropertyName = basePropertyName + "RemapInverted";
-            string rangePropertyName = basePropertyName + "Range";
+            string remapPropertyName = basePropertyName + "MapRemap";
+            string invertPropertyName = basePropertyName + "MapRemapInverted";
+            string rangePropertyName = basePropertyName + "MapRange";
-                Vector4 rangeVector = material.GetVector(remapPropertyName);
-                if (material.HasProperty(invertPropertyName) && material.GetFloat(invertPropertyName) > 0.0f)
+                if (material.HasProperty(remapPropertyName) && material.HasProperty(rangePropertyName))
-                    float s = rangeVector.x;
-                    rangeVector.x = rangeVector.y;
-                    rangeVector.y = s;
+                    Vector4 rangeVector = material.GetVector(remapPropertyName);
+                    if (material.HasProperty(invertPropertyName) && material.GetFloat(invertPropertyName) > 0.0f)
+                    {
+                        float s = rangeVector.x;
+                        rangeVector.x = rangeVector.y;
+                        rangeVector.y = s;
+                    }
+
+                    material.SetVector(rangePropertyName, rangeVector);
-                material.SetFloat(useMapPropertyName, 1.0f);
-                material.SetVector(rangePropertyName, rangeVector);
+                if (material.HasProperty(useMapPropertyName))
+                {
+                    material.SetFloat(useMapPropertyName, 1.0f);
+                }
-                int channel = (int)material.GetFloat(channelPropertyName);
-                switch (channel)
+                if (material.HasProperty(channelPropertyName))
-                    case 0:
-                        material.SetVector(channelMaskPropertyName, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
-                        break;
-                    case 1:
-                        material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
-                        break;
-                    case 2:
-                        material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 0.0f, 1.0f, 0.0f));
-                        break;
-                    case 3:
-                        material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                        break;
+                    int channel = (int)material.GetFloat(channelPropertyName);
+                    switch (channel)
+                    {
+                        case 0:
+                            material.SetVector(channelMaskPropertyName, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+                            break;
+                        case 1:
+                            material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+                            break;
+                        case 2:
+                            material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 0.0f, 1.0f, 0.0f));
+                            break;
+                        case 3:
+                            material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+                            break;
+                    }
-                material.SetFloat(useMapPropertyName, 0.0f);
-                material.SetVector(rangePropertyName, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
-                material.SetVector(channelMaskPropertyName, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+                if (material.HasProperty(useMapPropertyName))
+                {
+                    material.SetFloat(useMapPropertyName, 0.0f);
+                }
+                if (material.HasProperty(rangePropertyName))
+                {
+                    material.SetVector(rangePropertyName, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+                }
+                if (material.HasProperty(channelPropertyName))
+                {
+                    material.SetVector(channelMaskPropertyName, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+                }
             }
         }
 
-            //TODO see BaseLitUI.cs:SetupBaseLitKeywords (stencil etc)
             SetupBaseUnlitKeywords(material);
             SetupBaseUnlitMaterialPass(material);
 
                 }
             }
 
-            //TODO: stencil state, displacement, wind, depthoffset, tessellation
-
             SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
 
             //TODO: disable DBUFFER
             SetupTextureMaterialProperty(material, k_IridescenceThickness);
             SetupTextureMaterialProperty(material, k_IridescenceMask);
             SetupTextureMaterialProperty(material, k_CoatSmoothness);
+
+            // details
+            SetupTextureMaterialProperty(material, k_DetailMask);
+            SetupTextureMaterialProperty(material, k_DetailSmoothness);
 
             // Check if we are using specific UVs.
             TextureProperty.UVMapping[] uvIndices = new[]
                 (TextureProperty.UVMapping)material.GetFloat(k_IridescenceMaskMapUV),
                 (TextureProperty.UVMapping)material.GetFloat(k_CoatSmoothnessMapUV),
                 (TextureProperty.UVMapping)material.GetFloat(k_CoatNormalMapUV),
+                // Details
+                (TextureProperty.UVMapping)material.GetFloat(k_DetailMaskMapUV),
+                (TextureProperty.UVMapping)material.GetFloat(k_DetailSmoothnessMapUV),
+                (TextureProperty.UVMapping)material.GetFloat(k_DetailNormalMapUV),
             };
 
             // Set keyword for mapping
                 requireTriplanar = requireTriplanar || uvIndices[i] == TextureProperty.UVMapping.Triplanar;
             }
             CoreUtils.SetKeyword(material, "_USE_TRIPLANAR", requireTriplanar);
+
+            bool detailsEnabled = material.HasProperty(k_EnableDetails) && material.GetFloat(k_EnableDetails) > 0.0f;
+            CoreUtils.SetKeyword(material, "_USE_DETAILMAP", detailsEnabled);
 
             bool dualSpecularLobeEnabled = material.HasProperty(k_EnableDualSpecularLobe) && material.GetFloat(k_EnableDualSpecularLobe) > 0.0f;
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_DUAL_SPECULAR_LOBE", dualSpecularLobeEnabled);

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

             return "Packages/com.unity.render-pipelines.core/CoreRP/";
         }
 
+        public static T LoadAsset<T>(string relativePath) where T : UnityEngine.Object
+        {
+            return AssetDatabase.LoadAssetAtPath<T>(GetHDRenderPipelinePath() + relativePath);
+        }
+
         public static bool ResetMaterialKeywords(Material material)
         {
             MaterialResetter resetter;

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

             EditorGUILayout.PropertyField(d.supportSSR, _.GetContent("Support SSR|Enable memory use by SSR effect."));
             EditorGUILayout.PropertyField(d.supportSSAO, _.GetContent("Support SSAO|Enable memory use by SSAO effect."));
             EditorGUILayout.PropertyField(d.supportDBuffer, _.GetContent("Support Decal Buffer|Enable memory and variant of decal buffer."));
-            EditorGUILayout.PropertyField(d.supportMSAA, _.GetContent("Support Multi Sampling Anti-Aliasing|This feature doesn't work currently."));
-            EditorGUILayout.PropertyField(d.MSAASampleCount, _.GetContent("MSAA Sample Count|Allow to select the level of MSAA."));
+            // TODO: Implement MSAA - Hide for now as it doesn't work
+            //EditorGUILayout.PropertyField(d.supportMSAA, _.GetContent("Support Multi Sampling Anti-Aliasing|This feature doesn't work currently."));
+            //EditorGUILayout.PropertyField(d.MSAASampleCount, _.GetContent("MSAA Sample Count|Allow to select the level of MSAA."));
             EditorGUILayout.PropertyField(d.supportSubsurfaceScattering, _.GetContent("Support Subsurface Scattering"));
             EditorGUILayout.PropertyField(d.supportOnlyForward, _.GetContent("Support Only Forward|Remove all the memory and shader variant of GBuffer. The renderer can be switch to deferred anymore."));
             EditorGUILayout.PropertyField(d.supportMotionVectors, _.GetContent("Support Motion Vectors|Motion vector are use for Motion Blur, TAA, temporal re-projection of various effect like SSR."));

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRPass.template

         $AttributesMesh.uv2:                    #define ATTRIBUTES_NEED_TEXCOORD2
         $AttributesMesh.uv3:                    #define ATTRIBUTES_NEED_TEXCOORD3
         $AttributesMesh.color:                  #define ATTRIBUTES_NEED_COLOR
-        $VaryingsMeshToPS.positionWS:           #define VARYINGS_NEED_POSITION_WS
+        $VaryingsMeshToPS.positionRWS:          #define VARYINGS_NEED_POSITION_WS
         $VaryingsMeshToPS.normalWS:             #define VARYINGS_NEED_TANGENT_TO_WORLD
         $VaryingsMeshToPS.texCoord0:            #define VARYINGS_NEED_TEXCOORD0
         $VaryingsMeshToPS.texCoord1:            #define VARYINGS_NEED_TEXCOORD1
             $VertexDescriptionInputs.ViewSpaceBiTangent:        output.ViewSpaceBiTangent =          TransformWorldToViewDir(output.WorldSpaceBiTangent);
             $VertexDescriptionInputs.TangentSpaceBiTangent:     output.TangentSpaceBiTangent =       float3(0.0f, 1.0f, 0.0f);
             $VertexDescriptionInputs.ObjectSpacePosition:       output.ObjectSpacePosition =         input.positionOS;
-            $VertexDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          TransformObjectToWorld(input.positionOS);
+            $VertexDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS));
             $VertexDescriptionInputs.ViewSpacePosition:         output.ViewSpacePosition =           TransformWorldToView(output.WorldSpacePosition);
             $VertexDescriptionInputs.TangentSpacePosition:      output.TangentSpacePosition =        float3(0.0f, 0.0f, 0.0f);
             $VertexDescriptionInputs.WorldSpaceViewDirection:   output.WorldSpaceViewDirection =     GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition);
             output.worldToTangent = k_identity3x3;
             output.positionSS = input.positionCS;       // input.positionCS is SV_Position
 
-            $FragInputs.positionWS:         output.positionWS = input.positionWS;
+            $FragInputs.positionRWS:        output.positionRWS = input.positionRWS;
             $FragInputs.worldToTangent:     output.worldToTangent = BuildWorldToTangent(input.tangentWS, input.normalWS);
             $FragInputs.texCoord0:          output.texCoord0 = input.texCoord0;
             $FragInputs.texCoord1:          output.texCoord1 = input.texCoord1;
             $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);         // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
             $SurfaceDescriptionInputs.WorldSpaceTangent:         output.WorldSpaceTangent =           input.worldToTangent[0].xyz;
-            $SurfaceDescriptionInputs.ObjectSpaceTangent:        output.ObjectSpaceTangent =          mul((float3x3) unity_WorldToObject, output.WorldSpaceTangent);
-            $SurfaceDescriptionInputs.ViewSpaceTangent:          output.ViewSpaceTangent =            mul((float3x3) UNITY_MATRIX_V, output.WorldSpaceTangent);
+            $SurfaceDescriptionInputs.ObjectSpaceTangent:        output.ObjectSpaceTangent =          TransformWorldToObjectDir(output.WorldSpaceTangent);
+            $SurfaceDescriptionInputs.ViewSpaceTangent:          output.ViewSpaceTangent =            TransformWorldToViewDir(output.WorldSpaceTangent);
-            $SurfaceDescriptionInputs.ObjectSpaceBiTangent:      output.ObjectSpaceBiTangent =        mul((float3x3) unity_WorldToObject, output.WorldSpaceBiTangent);
-            $SurfaceDescriptionInputs.ViewSpaceBiTangent:        output.ViewSpaceBiTangent =          mul((float3x3) UNITY_MATRIX_V, output.WorldSpaceBiTangent);
+            $SurfaceDescriptionInputs.ObjectSpaceBiTangent:      output.ObjectSpaceBiTangent =        TransformWorldToObjectDir(output.WorldSpaceBiTangent);
+            $SurfaceDescriptionInputs.ViewSpaceBiTangent:        output.ViewSpaceBiTangent =          TransformWorldToViewDir(output.WorldSpaceBiTangent);
-            $SurfaceDescriptionInputs.ObjectSpaceViewDirection:  output.ObjectSpaceViewDirection =    mul((float3x3) unity_WorldToObject, output.WorldSpaceViewDirection);
-            $SurfaceDescriptionInputs.ViewSpaceViewDirection:    output.ViewSpaceViewDirection =      mul((float3x3) UNITY_MATRIX_V, output.WorldSpaceViewDirection);
+            $SurfaceDescriptionInputs.ObjectSpaceViewDirection:  output.ObjectSpaceViewDirection =    TransformWorldToObjectDir(output.WorldSpaceViewDirection);
+            $SurfaceDescriptionInputs.ViewSpaceViewDirection:    output.ViewSpaceViewDirection =      TransformWorldToViewDir(output.WorldSpaceViewDirection);
-            $SurfaceDescriptionInputs.WorldSpacePosition:        // TODO: FragInputs.positionWS is badly named -- it's camera relative, not in world space
-            $SurfaceDescriptionInputs.WorldSpacePosition:        // we have to fix it up here to match graph input expectations
-            $SurfaceDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          input.positionWS + _WorldSpaceCameraPos;
-            $SurfaceDescriptionInputs.ObjectSpacePosition:       output.ObjectSpacePosition =         mul(unity_WorldToObject, float4(input.positionWS + _WorldSpaceCameraPos, 1.0f)).xyz;
-            $SurfaceDescriptionInputs.ViewSpacePosition:         float4 posViewSpace =                mul(UNITY_MATRIX_V, float4(input.positionWS, 1.0f));
+            $SurfaceDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          GetAbsolutePositionWS(input.positionRWS);
+            $SurfaceDescriptionInputs.ObjectSpacePosition:       output.ObjectSpacePosition =         TransformWorldToObject(input.positionRWS);
+            $SurfaceDescriptionInputs.ViewSpacePosition:         float4 posViewSpace =                TransformWorldToView(input.positionRWS);
-            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(input.positionWS), _ProjectionParams.x);
+            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x);
-            
+
             $SurfaceDescriptionInputs.VertexColor:               output.VertexColor =                 input.color;
 
             $SurfaceDescriptionInputs.FaceSign:                  output.FaceSign =    input.isFrontFace;
         float3 bentNormalWS =                   surfaceData.normalWS;           // TODO : make bent normals work
 
         builtinData.opacity =                   surfaceDescription.Alpha;
-        builtinData.bakeDiffuseLighting =       SampleBakedGI(fragInputs.positionWS, bentNormalWS, fragInputs.texCoord1, fragInputs.texCoord2);    // see GetBuiltinData()
+        builtinData.bakeDiffuseLighting =       SampleBakedGI(fragInputs.positionRWS, bentNormalWS, fragInputs.texCoord1, fragInputs.texCoord2);    // see GetBuiltinData()
 
         // It is safe to call this function here as surfaceData have been filled
         // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
             // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
             // TODO: optimize more this code.
             // Add GI transmission contribution by resampling the GI for inverted vertex normal
-            builtinData.bakeDiffuseLighting += SampleBakedGI(fragInputs.positionWS, -fragInputs.worldToTangent[2], fragInputs.texCoord1, fragInputs.texCoord2) * bsdfData.transmittance;
+            builtinData.bakeDiffuseLighting += SampleBakedGI(fragInputs.positionRWS, -fragInputs.worldToTangent[2], fragInputs.texCoord1, fragInputs.texCoord2) * bsdfData.transmittance;
-        float4 shadowMask = SampleShadowMask(fragInputs.positionWS, fragInputs.texCoord1);
+        float4 shadowMask = SampleShadowMask(fragInputs.positionRWS, fragInputs.texCoord1);
         builtinData.shadowMask0 = shadowMask.x;
         builtinData.shadowMask1 = shadowMask.y;
         builtinData.shadowMask2 = shadowMask.z;

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRSubShader.cs

 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
             RequiredFields = new List<string>()
             {
                 "FragInputs.worldToTangent",
-                "FragInputs.positionWS",
+                "FragInputs.positionRWS",
                 "FragInputs.texCoord1",
                 "FragInputs.texCoord2"
             },
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             },
             RequiredFields = new List<string>()
             {
-                "FragInputs.positionWS",
+                "FragInputs.positionRWS",
             },
             StencilOverride = new List<string>()
             {
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             RequiredFields = new List<string>()
             {
                 "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             RequiredFields = new List<string>()
             {
 //                "FragInputs.worldToTangent",
-//                "FragInputs.positionWS",
+//                "FragInputs.positionRWS",
             },
             PixelShaderSlots = new List<int>()
             {
             subShader.AddShaderChunk("}", true);
 
             return subShader.GetShaderString(0);
+        }
+
+        public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
+        {
+            return renderPipelineAsset is HDRenderPipelineAsset;
         }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDSubShaderUtilities.cs

         struct VaryingsMeshToPS
         {
             [Semantic("SV_Position")]           Vector4 positionCS;
-            [Optional]                          Vector3 positionWS;
+            [Optional]                          Vector3 positionRWS;
             [Optional]                          Vector3 normalWS;
             [Optional]                          Vector4 tangentWS;      // w contain mirror sign
             [Optional]                          Vector2 texCoord0;
 
             public static Dependency[] tessellationDependencies = new Dependency[]
             {
-                new Dependency("VaryingsMeshToPS.positionWS",       "VaryingsMeshToDS.positionWS"),
+                new Dependency("VaryingsMeshToPS.positionRWS",       "VaryingsMeshToDS.positionRWS"),
                 new Dependency("VaryingsMeshToPS.normalWS",         "VaryingsMeshToDS.normalWS"),
                 new Dependency("VaryingsMeshToPS.tangentWS",        "VaryingsMeshToDS.tangentWS"),
                 new Dependency("VaryingsMeshToPS.texCoord0",        "VaryingsMeshToDS.texCoord0"),
 
             public static Dependency[] standardDependencies = new Dependency[]
             {
-                new Dependency("VaryingsMeshToPS.positionWS",       "AttributesMesh.positionOS"),
+                new Dependency("VaryingsMeshToPS.positionRWS",       "AttributesMesh.positionOS"),
                 new Dependency("VaryingsMeshToPS.normalWS",         "AttributesMesh.normalOS"),
                 new Dependency("VaryingsMeshToPS.tangentWS",        "AttributesMesh.tangentOS"),
                 new Dependency("VaryingsMeshToPS.texCoord0",        "AttributesMesh.uv0"),
 
         struct VaryingsMeshToDS
         {
-            Vector3 positionWS;
+            Vector3 positionRWS;
             Vector3 normalWS;
             [Optional]      Vector4 tangentWS;
             [Optional]      Vector2 texCoord0;
         {
             public static Dependency[] dependencies = new Dependency[]
             {
-                new Dependency("FragInputs.positionWS",         "VaryingsMeshToPS.positionWS"),
+                new Dependency("FragInputs.positionRWS",        "VaryingsMeshToPS.positionRWS"),
                 new Dependency("FragInputs.worldToTangent",     "VaryingsMeshToPS.tangentWS"),
                 new Dependency("FragInputs.worldToTangent",     "VaryingsMeshToPS.normalWS"),
                 new Dependency("FragInputs.texCoord0",          "VaryingsMeshToPS.texCoord0"),
                 new Dependency("SurfaceDescriptionInputs.ObjectSpaceBiTangent",      "SurfaceDescriptionInputs.WorldSpaceBiTangent"),
                 new Dependency("SurfaceDescriptionInputs.ViewSpaceBiTangent",        "SurfaceDescriptionInputs.WorldSpaceBiTangent"),
 
-                new Dependency("SurfaceDescriptionInputs.WorldSpacePosition",        "FragInputs.positionWS"),
-                new Dependency("SurfaceDescriptionInputs.ObjectSpacePosition",       "FragInputs.positionWS"),
-                new Dependency("SurfaceDescriptionInputs.ViewSpacePosition",         "FragInputs.positionWS"),
+                new Dependency("SurfaceDescriptionInputs.WorldSpacePosition",        "FragInputs.positionRWS"),
+                new Dependency("SurfaceDescriptionInputs.ObjectSpacePosition",       "FragInputs.positionRWS"),
+                new Dependency("SurfaceDescriptionInputs.ViewSpacePosition",         "FragInputs.positionRWS"),
-                new Dependency("SurfaceDescriptionInputs.WorldSpaceViewDirection",   "FragInputs.positionWS"),                   // we build WorldSpaceViewDirection using FragInputs.positionWS in GetWorldSpaceNormalizeViewDir()
+                new Dependency("SurfaceDescriptionInputs.WorldSpaceViewDirection",   "FragInputs.positionRWS"),                   // we build WorldSpaceViewDirection using FragInputs.positionRWS in GetWorldSpaceNormalizeViewDir()
                 new Dependency("SurfaceDescriptionInputs.ObjectSpaceViewDirection",  "SurfaceDescriptionInputs.WorldSpaceViewDirection"),
                 new Dependency("SurfaceDescriptionInputs.ViewSpaceViewDirection",    "SurfaceDescriptionInputs.WorldSpaceViewDirection"),
                 new Dependency("SurfaceDescriptionInputs.TangentSpaceViewDirection", "SurfaceDescriptionInputs.WorldSpaceViewDirection"),

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitPassForward.template

         $AttributesMesh.uv2:                    #define ATTRIBUTES_NEED_TEXCOORD2
         $AttributesMesh.uv3:                    #define ATTRIBUTES_NEED_TEXCOORD3
         $AttributesMesh.color:                  #define ATTRIBUTES_NEED_COLOR
-        $VaryingsMeshToPS.positionWS:           #define VARYINGS_NEED_POSITION_WS
+        $VaryingsMeshToPS.positionRWS:          #define VARYINGS_NEED_POSITION_WS
         $VaryingsMeshToPS.normalWS:             #define VARYINGS_NEED_TANGENT_TO_WORLD
         $VaryingsMeshToPS.texCoord0:            #define VARYINGS_NEED_TEXCOORD0
         $VaryingsMeshToPS.texCoord1:            #define VARYINGS_NEED_TEXCOORD1
             $VertexDescriptionInputs.ViewSpaceBiTangent:        output.ViewSpaceBiTangent =          TransformWorldToViewDir(output.WorldSpaceBiTangent);
             $VertexDescriptionInputs.TangentSpaceBiTangent:     output.TangentSpaceBiTangent =       float3(0.0f, 1.0f, 0.0f);
             $VertexDescriptionInputs.ObjectSpacePosition:       output.ObjectSpacePosition =         input.positionOS;
-            $VertexDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          TransformObjectToWorld(input.positionOS);
+            $VertexDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS));
             $VertexDescriptionInputs.ViewSpacePosition:         output.ViewSpacePosition =           TransformWorldToView(output.WorldSpacePosition);
             $VertexDescriptionInputs.TangentSpacePosition:      output.TangentSpacePosition =        float3(0.0f, 0.0f, 0.0f);
             $VertexDescriptionInputs.WorldSpaceViewDirection:   output.WorldSpaceViewDirection =     GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition);
             output.worldToTangent = k_identity3x3;
             output.positionSS = input.positionCS;       // input.positionCS is SV_Position
 
-            $FragInputs.positionWS:         output.positionWS = input.positionWS;
+            $FragInputs.positionRWS:        output.positionRWS = input.positionRWS;
             $FragInputs.worldToTangent:     output.worldToTangent = BuildWorldToTangent(input.tangentWS, input.normalWS);
             $FragInputs.texCoord0:          output.texCoord0 = input.texCoord0;
             $FragInputs.texCoord1:          output.texCoord1 = input.texCoord1;
             $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);         // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
             $SurfaceDescriptionInputs.WorldSpaceTangent:         output.WorldSpaceTangent =           input.worldToTangent[0].xyz;
-            $SurfaceDescriptionInputs.ObjectSpaceTangent:        output.ObjectSpaceTangent =          mul((float3x3) unity_WorldToObject, output.WorldSpaceTangent);
-            $SurfaceDescriptionInputs.ViewSpaceTangent:          output.ViewSpaceTangent =            mul((float3x3) UNITY_MATRIX_V, output.WorldSpaceTangent);
+            $SurfaceDescriptionInputs.ObjectSpaceTangent:        output.ObjectSpaceTangent =          TransformWorldToObjectDir(output.WorldSpaceTangent);
+            $SurfaceDescriptionInputs.ViewSpaceTangent:          output.ViewSpaceTangent =            TransformWorldToViewDir(output.WorldSpaceTangent);
-            $SurfaceDescriptionInputs.ObjectSpaceBiTangent:      output.ObjectSpaceBiTangent =        mul((float3x3) unity_WorldToObject, output.WorldSpaceBiTangent);
-            $SurfaceDescriptionInputs.ViewSpaceBiTangent:        output.ViewSpaceBiTangent =          mul((float3x3) UNITY_MATRIX_V, output.WorldSpaceBiTangent);
+            $SurfaceDescriptionInputs.ObjectSpaceBiTangent:      output.ObjectSpaceBiTangent =        TransformWorldToObjectDir(output.WorldSpaceBiTangent);
+            $SurfaceDescriptionInputs.ViewSpaceBiTangent:        output.ViewSpaceBiTangent =          TransformWorldToViewDir(output.WorldSpaceBiTangent);
-            $SurfaceDescriptionInputs.ObjectSpaceViewDirection:  output.ObjectSpaceViewDirection =    mul((float3x3) unity_WorldToObject, output.WorldSpaceViewDirection);
-            $SurfaceDescriptionInputs.ViewSpaceViewDirection:    output.ViewSpaceViewDirection =      mul((float3x3) UNITY_MATRIX_V, output.WorldSpaceViewDirection);
+            $SurfaceDescriptionInputs.ObjectSpaceViewDirection:  output.ObjectSpaceViewDirection =    TransformWorldToObjectDir(output.WorldSpaceViewDirection);
+            $SurfaceDescriptionInputs.ViewSpaceViewDirection:    output.ViewSpaceViewDirection =      TransformWorldToViewDir(output.WorldSpaceViewDirection);
-            $SurfaceDescriptionInputs.WorldSpacePosition:        // TODO: FragInputs.positionWS is badly named -- it's camera relative, not in world space
-            $SurfaceDescriptionInputs.WorldSpacePosition:        // we have to fix it up here to match graph input expectations
-            $SurfaceDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          input.positionWS + _WorldSpaceCameraPos;
-            $SurfaceDescriptionInputs.ObjectSpacePosition:       output.ObjectSpacePosition =         mul(unity_WorldToObject, float4(input.positionWS + _WorldSpaceCameraPos, 1.0f)).xyz;
-            $SurfaceDescriptionInputs.ViewSpacePosition:         float4 posViewSpace =                mul(UNITY_MATRIX_V, float4(input.positionWS, 1.0f));
+            $SurfaceDescriptionInputs.WorldSpacePosition:        output.WorldSpacePosition =          GetAbsolutePositionWS(input.positionRWS);
+            $SurfaceDescriptionInputs.ObjectSpacePosition:       output.ObjectSpacePosition =         TransformWorldToObject(input.positionRWS);
+            $SurfaceDescriptionInputs.ViewSpacePosition:         float4 posViewSpace =                TransformWorldToView(input.positionRWS);
-            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(input.positionWS), _ProjectionParams.x);
-            
+            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x);
+
-            
+
             $SurfaceDescriptionInputs.VertexColor:               output.VertexColor =                 input.color;
 
             $SurfaceDescriptionInputs.FaceSign:                  output.FaceSign =    input.isFrontFace;

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitSubShader.cs

 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
             subShader.AddShaderChunk("}", true);
 
             return subShader.GetShaderString(0);
+        }
+
+        public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
+        {
+            return renderPipelineAsset is HDRenderPipelineAsset;
         }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/HDRenderPipelineAsset.asset

     enableVolumetric: 1
     diffuseGlobalDimmer: 1
     specularGlobalDimmer: 1
-    enableForwardRenderingOnly: 0
+    enableForwardRenderingOnly: 1
     enableDepthPrepassWithDeferredRendering: 0
     enableTransparentPrepass: 1
     enableMotionVectors: 1

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

             return new Color(r, g, b, 1.0f);
         }
 
+        // When true, a mesh will be display to represent the area light (Can only be change in editor, component is added in Editor)
+        public bool displayAreaLightEmissiveMesh = false;
+
 #if UNITY_EDITOR
 
         private void DrawGizmos(bool selected)

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

         decalStart = 0;
     #endif
 
-        float3 positionWS = GetAbsolutePositionWS(posInput.positionWS);
+        float3 positionRWS = posInput.positionWS;
-        float3 positionWSDdx = ddx(positionWS);
-        float3 positionWSDdy = ddy(positionWS);
+        float3 positionRWSDdx = ddx(positionRWS);
+        float3 positionRWSDdy = ddy(positionRWS);
-            float3 positionDS = mul(decalData.worldToDecal, float4(positionWS, 1.0)).xyz;
+            // Get the relative world camera to decal matrix
+            float4x4 worldToDecal = ApplyCameraTranslationToInverseMatrix(decalData.worldToDecal);
+
+            float3 positionDS = mul(worldToDecal, float4(positionRWS, 1.0)).xyz;
             positionDS = positionDS * float3(1.0, -1.0, 1.0) + float3(0.5, 0.0f, 0.5);  // decal clip space
             if ((all(positionDS.xyz > 0.0f) && all(1.0f - positionDS.xyz > 0.0f)))
             {
                 float2 sampleMask = clamp(positionDS.xz * decalData.maskScaleBias.xy + decalData.maskScaleBias.zw, maskMin, maskMax);
 
                 // need to compute the mipmap LOD manually because we are sampling inside a loop
-                float3 positionDSDdx = mul(decalData.worldToDecal, float4(positionWSDdx, 0.0)).xyz; // transform the derivatives to decal space, any translation is irrelevant
-                float3 positionDSDdy = mul(decalData.worldToDecal, float4(positionWSDdy, 0.0)).xyz;
+                float3 positionDSDdx = mul(worldToDecal, float4(positionRWSDdx, 0.0)).xyz; // transform the derivatives to decal space, any translation is irrelevant
+                float3 positionDSDdy = mul(worldToDecal, float4(positionRWSDdy, 0.0)).xyz;
 
                 float2 sampleDiffuseDdx = positionDSDdx.xz * decalData.diffuseScaleBias.xy; // factor in the atlas scale
                 float2 sampleDiffuseDdy = positionDSDdy.xz * decalData.diffuseScaleBias.xy;

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

 
             if (!m_GgxIblSampleData)
             {
-                m_GgxIblSampleData = new RenderTexture(m_GgxIblMaxSampleCount, k_GgxIblMipCountMinusOne, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear);
+                m_GgxIblSampleData = new RenderTexture(m_GgxIblMaxSampleCount, k_GgxIblMipCountMinusOne, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
                 m_GgxIblSampleData.useMipMap = false;
                 m_GgxIblSampleData.autoGenerateMips = false;
                 m_GgxIblSampleData.enableRandomWrite = true;

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

 #endif
 
     GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
-                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
+                        input.positionRWS, input.worldToTangent[2].xyz, layerTexCoord);
 }
 
 void ApplyDisplacementTileScale(inout float height0, inout float height1, inout float height2, inout float height3)

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

 
     // TODO: Sample lightmap/lightprobe/volume proxy
     // This should also handle projective lightmap
-    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, bentNormalWS, input.texCoord1, input.texCoord2);
+    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionRWS, bentNormalWS, input.texCoord1, input.texCoord2);
 
     // It is safe to call this function here as surfaceData have been filled
     // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
         // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
         // TODO: optimize more this code.
         // Add GI transmission contribution by resampling the GI for inverted vertex normal
-        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
+        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionRWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
-    float4 shadowMask = SampleShadowMask(input.positionWS, input.texCoord1);
+    float4 shadowMask = SampleShadowMask(input.positionRWS, input.texCoord1);
     builtinData.shadowMask0 = shadowMask.x;
     builtinData.shadowMask1 = shadowMask.y;
     builtinData.shadowMask2 = shadowMask.z;
     #endif
                             input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, _UVMappingMaskEmissive, _UVMappingMaskEmissive,
                             _EmissiveColorMap_ST.xy, _EmissiveColorMap_ST.zw, float2(0.0, 0.0), float2(0.0, 0.0), 1.0, false,
-                            input.positionWS, _TexWorldScaleEmissive,
+                            input.positionRWS, _TexWorldScaleEmissive,
                             mappingType, layerTexCoord);
 
     #ifndef LAYERED_LIT_SHADER

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

     layerTexCoord.vertexTangentWS0 = input.worldToTangent[0];
     layerTexCoord.vertexBitangentWS0 = input.worldToTangent[1];
 
-    // TODO: We should use relative camera position here - This will be automatic when we will move to camera relative space.
-    float3 dPdx = ddx_fine(input.positionWS);
-    float3 dPdy = ddy_fine(input.positionWS);
+    float3 dPdx = ddx_fine(input.positionRWS);
+    float3 dPdy = ddy_fine(input.positionRWS);
 
     float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
     float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
 // in function with FragInputs input as parameters
 // layerTexCoord must have been initialize to 0 outside of this function
 void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
-                      float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
+                      float3 positionRWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
 {
     layerTexCoord.vertexNormalWS = vertexNormalWS;
     layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
     // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
     ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, _UVMappingMask, _UVDetailsMappingMask,
                             _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase,
-                            positionWS, _TexWorldScale,
+                            positionRWS, _TexWorldScale,
                             mappingType, layerTexCoord);
 }
 
 #endif
 
     GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
-                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
+                        input.positionRWS, input.worldToTangent[2].xyz, layerTexCoord);
 }
 
 #include "LitDataDisplacement.hlsl"

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

                                     // scale and bias for base and detail + global tiling factor (for layered lit only)
                                     float2 texScale, float2 texBias, float2 texScaleDetails, float2 texBiasDetails, float additionalTiling, float linkDetailsWithBase,
                                     // parameter for planar/triplanar
-                                    float3 positionWS, float worldScale,
+                                    float3 positionRWS, float worldScale,
                                     // mapping type and output
                                     int mappingType, inout LayerTexCoord layerTexCoord)
 {
     float2 uvXY;
     float2 uvZY;
 
-    GetTriplanarCoordinate(GetAbsolutePositionWS(positionWS) * worldScale, uvXZ, uvXY, uvZY);
+    GetTriplanarCoordinate(GetAbsolutePositionWS(positionRWS) * worldScale, uvXZ, uvXY, uvZY);
 
     // Planar is just XZ of triplanar
     if (mappingType == UV_MAPPING_PLANAR)

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

-float3 GetVertexDisplacement(float3 positionWS, float3 normalWS, float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 vertexColor)
+// Note: positionWS can be either in camera relative space or not
+float3 GetVertexDisplacement(float3 positionRWS, float3 normalWS, float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 vertexColor)
-    GetLayerTexCoord(texCoord0, texCoord1, texCoord2, texCoord3, positionWS, normalWS, layerTexCoord);
+    GetLayerTexCoord(texCoord0, texCoord1, texCoord2, texCoord3, positionRWS, 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/
 
-void ApplyVertexModification(AttributesMesh input, float3 normalWS, inout float3 positionWS, float4 time)
+// Note: positionWS can be either in camera relative space or not
+void ApplyVertexModification(AttributesMesh input, float3 normalWS, inout float3 positionRWS, float4 time)
-    positionWS += GetVertexDisplacement(positionWS, normalWS,
+    positionRWS += GetVertexDisplacement(positionRWS, normalWS,
     #ifdef ATTRIBUTES_NEED_TEXCOORD0
         input.uv0,
     #else
 #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);
+    // current wind implementation is in absolute world space
+    float3 rootWP = GetObjectAbsolutePositionWS();
+    float3 absolutePositionWS = GetAbsolutePositionWS(positionRWS);
+    ApplyWindDisplacement(absolutePositionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, input.color.a, time);
+    positionRWS = GetCameraRelativePositionWS(absolutePositionWS);
 #endif
 }
 
 // y - 2->0 edge
 // z - 0->1 edge
 // w - inside tessellation factor
-void ApplyTessellationModification(VaryingsMeshToDS input, float3 normalWS, inout float3 positionWS)
+void ApplyTessellationModification(VaryingsMeshToDS input, float3 normalWS, inout float3 positionRWS)
-    positionWS += GetVertexDisplacement(positionWS, normalWS,
+    positionRWS += GetVertexDisplacement(positionRWS, normalWS,
     #ifdef VARYINGS_DS_NEED_TEXCOORD0
         input.texCoord0,
     #else

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

+// Return camera relative probe volume world to object transformation
+float4x4 GetProbeVolumeWorldToObject()
+{
+    return ApplyCameraTranslationToInverseMatrix(unity_ProbeVolumeWorldToObject);
+}
+    
-float3 SampleBakedGI(float3 positionWS, float3 normalWS, float2 uvStaticLightmap, float2 uvDynamicLightmap)
+float3 SampleBakedGI(float3 positionRWS, float3 normalWS, float2 uvStaticLightmap, float2 uvDynamicLightmap)
 {
     // If there is no lightmap, it assume lightprobe
 #if !defined(LIGHTMAP_ON) && !defined(DYNAMICLIGHTMAP_ON)
     }
     else
     {
-        // TODO: We use GetAbsolutePositionWS(positionWS) to handle the camera relative case here but this should be part of the unity_ProbeVolumeWorldToObject matrix on C++ side (sadly we can't modify it for HDRenderPipeline...)
-        return SampleProbeVolumeSH4(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), GetAbsolutePositionWS(positionWS), normalWS, unity_ProbeVolumeWorldToObject,
+        return SampleProbeVolumeSH4(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), positionRWS, normalWS, GetProbeVolumeWorldToObject(),
                                     unity_ProbeVolumeParams.y, unity_ProbeVolumeParams.z, unity_ProbeVolumeMin, unity_ProbeVolumeSizeInv);
     }
 
 #endif
 }
 
-float4 SampleShadowMask(float3 positionWS, float2 uvStaticLightmap) // normalWS not use for now
+float4 SampleShadowMask(float3 positionRWS, float2 uvStaticLightmap) // normalWS not use for now
 {
 #if defined(LIGHTMAP_ON)
     float2 uv = uvStaticLightmap * unity_LightmapST.xy + unity_LightmapST.zw;
     if (unity_ProbeVolumeParams.x == 1.0)
     {
-        // TODO: We use GetAbsolutePositionWS(positionWS) to handle the camera relative case here but this should be part of the unity_ProbeVolumeWorldToObject matrix on C++ side (sadly we can't modify it for HDRenderPipeline...)
-        rawOcclusionMask = SampleProbeOcclusion(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), GetAbsolutePositionWS(positionWS), unity_ProbeVolumeWorldToObject,
+        rawOcclusionMask = SampleProbeOcclusion(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), positionRWS, GetProbeVolumeWorldToObject(),
                                                 unity_ProbeVolumeParams.y, unity_ProbeVolumeParams.z, unity_ProbeVolumeMin, unity_ProbeVolumeSizeInv);
     }
     else

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

 #endif
  
             // perceptualRoughness is use as input and output here
-            GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N, V, preLightData.iblAnisotropy[0], preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX], iblN[BASE_LOBEA_IDX], preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX]);
-            GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N, V, preLightData.iblAnisotropy[1], preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX], iblN[BASE_LOBEB_IDX], preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX]);
+            float3 outNormal;
+            float outPerceptualRoughness;
+            GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N[0], V, preLightData.iblAnisotropy[0], preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX], outNormal, outPerceptualRoughness);
+            iblN[BASE_LOBEA_IDX] = outNormal;
+            preLightData.iblPerceptualRoughness[BASE_LOBEA_IDX] = outPerceptualRoughness;
+            GetGGXAnisotropicModifiedNormalAndRoughness(bsdfData.bitangentWS, bsdfData.tangentWS, N[0], V, preLightData.iblAnisotropy[1], preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX], outNormal, outPerceptualRoughness);
+            iblN[BASE_LOBEB_IDX] = outNormal;
+            preLightData.iblPerceptualRoughness[BASE_LOBEB_IDX] = outPerceptualRoughness;
 
             iblN[COAT_LOBE_IDX] = N[COAT_NORMAL_IDX]; // no anisotropy for coat.
         }

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

         _MetallicMapUV("Metallic Map UV", Float) = 0.0
         _MetallicMapUVLocal("Metallic Map UV Local", Float) = 0.0
         _MetallicMapChannel("Metallic Map Channel", Float) = 0.0
-        _MetallicMapChannelMask("Metallic Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _MetallicRemap("Metallic Remap", Vector) = (0, 1, 0, 0)
-        [HideInInspector] _MetallicRange("Metallic Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _MetallicMapChannelMask("Metallic Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _MetallicMapRemap("Metallic Remap", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _MetallicMapRange("Metallic Range", Vector) = (0, 1, 0, 0)
 
         _DielectricIor("DielectricIor IOR", Range(1.0, 2.5)) = 1.5
 
         _SmoothnessAUseMap("SmoothnessA Use Map", Float) = 0
         _SmoothnessAMapUV("SmoothnessA Map UV", Float) = 0.0
-        _SmoothnessAMapUVLocal("_SmoothnessA Map UV Local", Float) = 0.0
+        _SmoothnessAMapUVLocal("SmoothnessA Map UV Local", Float) = 0.0
-        _SmoothnessAMapChannelMask("SmoothnessA Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _SmoothnessARemap("SmoothnessA Remap", Vector)  = (0, 1, 0, 0)
-        [ToggleUI] _SmoothnessARemapInverted("Invert SmoothnessA Remap", Float) = 0.0
-        [HideInInspector] _SmoothnessARange("SmoothnessA Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _SmoothnessAMapChannelMask("SmoothnessA Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _SmoothnessAMapRemap("SmoothnessA Remap", Vector)  = (0, 1, 0, 0)
+        [ToggleUI] _SmoothnessAMapRemapInverted("Invert SmoothnessA Remap", Float) = 0.0
+        [HideInInspector] _SmoothnessAMapRange("SmoothnessA Range", Vector) = (0, 1, 0, 0)
 
         [ToggleUI] _EnableDualSpecularLobe("Enable Dual Specular Lobe", Float) = 0.0 // UI only
         [HideInInspector] _SmoothnessBMapShow("SmoothnessB Map Show", Float) = 0
         _SmoothnessBMapUV("SmoothnessB Map UV", Float) = 0.0
         _SmoothnessAMapUVLocal("_SmoothnessB Map UV Local", Float) = 0.0
         _SmoothnessBMapChannel("SmoothnessB Map Channel", Float) = 0.0
-        _SmoothnessBMapChannelMask("SmoothnessB Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _SmoothnessBRemap("SmoothnessB Remap", Vector) = (0, 1, 0, 0)
-        [ToggleUI] _SmoothnessBRemapInverted("Invert SmoothnessB Remap", Float) = 0.0
-        [HideInInspector] _SmoothnessBRange("SmoothnessB Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _SmoothnessBMapChannelMask("SmoothnessB Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _SmoothnessBMapRemap("SmoothnessB Remap", Vector) = (0, 1, 0, 0)
+        [ToggleUI] _SmoothnessBMapRemapInverted("Invert SmoothnessB Remap", Float) = 0.0
+        [HideInInspector] _SmoothnessBMapRange("SmoothnessB Range", Vector) = (0, 1, 0, 0)
         _LobeMix("Lobe Mix", Range(0.0, 1.0)) = 0
 
         [ToggleUI] _VlayerRecomputePerLight("Vlayer Recompute Per Light", Float) = 0.0 // UI only
         _AnisotropyMapUV("Anisotropy Map UV", Float) = 0.0
         _AnisotropyMapUVLocal("Anisotropy Map UV Local", Float) = 0.0
         _AnisotropyMapChannel("Anisotropy Map Channel", Float) = 0.0
-        _AnisotropyMapChannelMask("Anisotropy Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _AnisotropyRemap("Anisotropy Remap", Vector) = (0, 1, 0, 0)
-        [HideInInspector] _AnisotropyRange("Anisotropy Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _AnisotropyMapChannelMask("Anisotropy Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _AnisotropyMapRemap("Anisotropy Remap", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _AnisotropyMapRange("Anisotropy Range", Vector) = (0, 1, 0, 0)
 
         [ToggleUI] _EnableCoat("Enable Coat", Float) = 0.0 // UI only
         [HideInInspector] _CoatSmoothnessMapShow("CoatSmoothness Show", Float) = 0
         _CoatSmoothnessMapUV("CoatSmoothness Map UV", Float) = 0.0
         _CoatSmoothnessMapUVLocal("CoatSmoothness Map UV Local", Float) = 0.0
         _CoatSmoothnessMapChannel("CoatSmoothness Map Channel", Float) = 0.0
-        _CoatSmoothnessMapChannelMask("CoatSmoothness Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _CoatSmoothnessRemap("CoatSmoothness Remap", Vector) = (0, 1, 0, 0)
-        [ToggleUI] _CoatSmoothnessRemapInverted("Invert CoatSmoothness Remap", Float) = 0.0
-        [HideInInspector] _CoatSmoothnessRange("CoatSmoothness Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _CoatSmoothnessMapChannelMask("CoatSmoothness Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _CoatSmoothnessMapRemap("CoatSmoothness Remap", Vector) = (0, 1, 0, 0)
+        [ToggleUI] _CoatSmoothnessMapRemapInverted("Invert CoatSmoothness Remap", Float) = 0.0
+        [HideInInspector] _CoatSmoothnessMapRange("CoatSmoothness Range", Vector) = (0, 1, 0, 0)
 
         _CoatIor("Coat IOR", Range(1.0001, 2.0)) = 1.5
         _CoatThickness("Coat Thickness", Range(0.0, 0.99)) = 0.0
         _NormalMap("NormalMap", 2D) = "bump" {}     // Tangent space normal map
         _NormalMapUV("NormalMapUV", Float) = 0.0
         _NormalMapUVLocal("NormalMapUV Local", Float) = 0.0
-        _NormalMapObjSpace("NormalMapUV Local", Float) = 0.0
+        _NormalMapObjSpace("NormalMapObjSpace", Float) = 0.0
         _NormalScale("Normal Scale", Range(0.0, 2.0)) = 1
 
         [HideInInspector] _AmbientOcclusionMapShow("AmbientOcclusion Map Show", Float) = 0
         _AmbientOcclusionMapUV("AmbientOcclusion Map UV", Float) = 0.0
         _AmbientOcclusionMapUVLocal("AmbientOcclusion Map UV Local", Float) = 0.0
         _AmbientOcclusionMapChannel("AmbientOcclusion Map Channel", Float) = 0.0
-        _AmbientOcclusionMapChannelMask("AmbientOcclusion Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _AmbientOcclusionRemap("AmbientOcclusion Remap", Vector) = (0, 1, 0, 0)
-        [HideInInspector] _AmbientOcclusionRange("AmbientOcclusion Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _AmbientOcclusionMapChannelMask("AmbientOcclusion Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _AmbientOcclusionMapRemap("AmbientOcclusion Remap", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _AmbientOcclusionMapRange("AmbientOcclusion Range", Vector) = (0, 1, 0, 0)
 
         [HideInInspector] _EmissiveColorMapShow("Emissive Color Map Show", Float) = 0.0
         [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
         _SubsurfaceMaskMapUV("Subsurface Mask Map UV", Float) = 0.0
         _SubsurfaceMaskMapUVLocal("Subsurface Mask UV Local", Float) = 0.0
         _SubsurfaceMaskMapChannel("Subsurface Mask Map Channel", Float) = 0.0
-        _SubsurfaceMaskMapChannelMask("Subsurface Mask Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _SubsurfaceMaskRemap("Subsurface Mask Remap", Vector) = (0, 1, 0, 0)
-        [HideInInspector] _SubsurfaceMaskRange("Subsurface Mask Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _SubsurfaceMaskMapChannelMask("Subsurface Mask Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _SubsurfaceMaskMapRemap("Subsurface Mask Remap", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _SubsurfaceMaskMapRange("Subsurface Mask Range", Vector) = (0, 1, 0, 0)
 
         [ToggleUI] _EnableTransmission("Enable Transmission", Float) = 0.0
         [HideInInspector] _ThicknessMapShow("Thickness Show", Float) = 0
         _ThicknessMapUV("Thickness Map UV", Float) = 0.0
         _ThicknessMapUVLocal("Thickness Map UV Local", Float) = 0.0
         _ThicknessMapChannel("Thickness Map Channel", Float) = 0.0
-        _ThicknessMapChannelMask("Thickness Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
-        [ToggleUI] _ThicknessRemapInverted("Invert Thickness Remap", Float) = 0.0
-        [HideInInspector] _ThicknessRange("Thickness Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _ThicknessMapChannelMask("Thickness Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _ThicknessMapRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
+        [ToggleUI] _ThicknessMapRemapInverted("Invert Thickness Remap", Float) = 0.0
+        [HideInInspector] _ThicknessMapRange("Thickness Range", Vector) = (0, 1, 0, 0)
 
         [ToggleUI] _EnableIridescence("Enable Iridescence", Float) = 0.0 // UI only
         _IridescenceIor("TopIOR over iridescent layer", Range(1.0, 2.0)) = 1.5
         _IridescenceThicknessMapUV("IridescenceThickness Map UV", Float) = 0.0
         _IridescenceThicknessMapLocal("IridescenceThickness Map UV Local", Float) = 0.0
         _IridescenceThicknessMapChannel("IridescenceThickness Map Channel", Float) = 0.0
-        _IridescenceThicknessMapChannelMask("IridescenceThickness Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _IridescenceThicknessRemap("IridescenceThickness Remap", Vector) = (0, 1, 0, 0)
-        [ToggleUI] _IridescenceThicknessRemapInverted("Invert IridescenceThickness Remap", Float) = 0.0
-        [HideInInspector] _IridescenceThicknessRange("IridescenceThickness Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _IridescenceThicknessMapChannelMask("IridescenceThickness Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _IridescenceThicknessMapRemap("IridescenceThickness Remap", Vector) = (0, 1, 0, 0)
+        [ToggleUI] _IridescenceThicknessMapRemapInverted("Invert IridescenceThickness Remap", Float) = 0.0
+        [HideInInspector] _IridescenceThicknessMapRange("IridescenceThickness Range", Vector) = (0, 1, 0, 0)
 
         [HideInInspector] _IridescenceMaskMapShow("Iridescence Mask Map Show", Float) = 0
         _IridescenceMask("Iridescence Mask", Range(0.0, 1.0)) = 1.0
         _IridescenceMaskMapUVLocal("Iridescence Mask UV Local", Float) = 0.0
         _IridescenceMaskMapChannel("Iridescence Mask Map Channel", Float) = 0.0
-        _IridescenceMaskMapChannelMask("Iridescence Mask Map Channel Mask", Vector) = (1, 0, 0, 0)
-        _IridescenceMaskRemap("Iridescence Mask Remap", Vector) = (0, 1, 0, 0)
-        [HideInInspector] _IridescenceMaskRange("Iridescence Mask Range", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _IridescenceMaskMapChannelMask("Iridescence Mask Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _IridescenceMaskMapRemap("Iridescence Mask Remap", Vector) = (0, 1, 0, 0)
+        [HideInInspector] _IridescenceMaskMapRange("Iridescence Mask Range", Vector) = (0, 1, 0, 0)
+        // Detail map (mask, normal, smoothness)
+        [ToggleUI] _EnableDetails("Enable Details", Float) = 0.0
+        [HideInInspector] _DetailMaskMapShow("DetailMask Map Show", Float) = 0
+        _DetailMaskMap("DetailMask Map", 2D) = "white" {}
+        _DetailMaskMapUV("DetailMask Map UV", Float) = 0.0
+        _DetailMaskMapUVLocal("DetailMask Map UV Local", Float) = 0.0
+        _DetailMaskMapChannel("DetailMask Map Channel", Float) = 0.0
+        [HideInInspector] _DetailMaskMapChannelMask("DetailSmoothness Map Channel Mask", Vector) = (1, 0, 0, 0)
+
+        [HideInInspector] _DetailNormalMapShow("DetailNormalMap Show", Float) = 0.0
+        _DetailNormalMap("DetailNormalMap", 2D) = "bump" {}     // Tangent space normal map
+        _DetailNormalMapUV("DetailNormalMapUV", Float) = 0.0
+        _DetailNormalMapUVLocal("DetailNormalMapUV Local", Float) = 0.0
+        _DetailNormalScale("DetailNormal Scale", Range(0.0, 2.0)) = 1
+
+        [HideInInspector] _DetailSmoothnessMapShow("DetailSmoothness Map Show", Float) = 0
+        _DetailSmoothnessMap("DetailSmoothness Map", 2D) = "grey" {} // Neutral is 0.5 for detail map
+        _DetailSmoothnessMapUV("DetailSmoothness Map UV", Float) = 0.0
+        _DetailSmoothnessMapUVLocal("DetailSmoothness Map UV Local", Float) = 0.0
+        _DetailSmoothnessMapChannel("DetailSmoothness Map Channel", Float) = 0.0
+        [HideInInspector] _DetailSmoothnessMapChannelMask("DetailSmoothness Map Channel Mask", Vector) = (1, 0, 0, 0)
+        _DetailSmoothnessMapRemap("DetailSmoothness Remap", Vector)  = (0, 1, 0, 0)
+        [ToggleUI] _DetailSmoothnessMapRemapInverted("Invert SmoothnessA Remap", Float) = 0.0
+        [HideInInspector] _DetailSmoothnessMapRange("DetailSmoothness Range", Vector) = (0, 1, 0, 0)
+        _DetailSmoothnessScale("DetailSmoothness Scale", Range(0.0, 2.0)) = 1
+
+        // Distortion
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
         [ToggleUI] _DistortionEnable("Enable Distortion", Float) = 0.0
         [ToggleUI] _DistortionOnly("Distortion Only", Float) = 0.0
         // Sections show values.
         [HideInInspector] _MaterialFeaturesShow("_MaterialFeaturesShow", Float) = 1.0
         [HideInInspector] _StandardShow("_StandardShow", Float) = 0.0
+        [HideInInspector] _DetailsShow("_DetailsShow", Float) = 0.0
         [HideInInspector] _EmissiveShow("_EmissiveShow", Float) = 0.0
         [HideInInspector] _CoatShow("_CoatShow", Float) = 0.0
         [HideInInspector] _DebugShow("_DebugShow", Float) = 0.0
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DOUBLESIDED_ON
 
-    #pragma shader_feature _NORMALMAP_TANGENT_SPACE
+    #pragma shader_feature _USE_DETAILMAP
     #pragma shader_feature _USE_UV2
     #pragma shader_feature _USE_UV3
     #pragma shader_feature _USE_TRIPLANAR

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

 
 void InitializeMappingData(FragInputs input, out TextureUVMapping uvMapping)
 {
-    float3 position = GetAbsolutePositionWS(input.positionWS);
     float2 uvXZ;
     float2 uvXY;
     float2 uvZY;
     uvMapping.texcoords[TEXCOORD_INDEX_UV3][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV3][1] = input.texCoord3.xy;
 
     // planar/triplanar
-    GetTriplanarCoordinate(position, uvXZ, uvXY, uvZY);
+    GetTriplanarCoordinate(GetAbsolutePositionWS(input.positionRWS), uvXZ, uvXY, uvZY);
-    position = TransformWorldToObject(position);
-    GetTriplanarCoordinate(position, uvXZ, uvXY, uvZY);
+    GetTriplanarCoordinate(TransformWorldToObject(input.positionRWS), uvXZ, uvXY, uvZY);
     uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_XY][1] = uvXY;
     uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_YZ][1] = uvZY;
     uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_ZX][1] = uvXZ;
     uvMapping.vertexTangentWS[0] = input.worldToTangent[0];
     uvMapping.vertexBitangentWS[0] = input.worldToTangent[1];
 
-    float3 dPdx = ddx_fine(input.positionWS);
-    float3 dPdy = ddy_fine(input.positionWS);
+    float3 dPdx = ddx_fine(input.positionRWS);
+    float3 dPdy = ddy_fine(input.positionRWS);
 
     float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
     float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
 }
 
 #define SAMPLE_TEXTURE2D_SCALE_BIAS(name) SampleTexture2DTriplanarScaleBias(name, sampler##name, name##UV, name##UVLocal, name##_ST, uvMapping)
-#define SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(name, scale) SampleTexture2DTriplanarNormalScaleBias(name, sampler##name, name##UV, name##UVLocal, name##_ST, name##ObjSpace, uvMapping, scale)
+#define SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(name, scale, objSpace) SampleTexture2DTriplanarNormalScaleBias(name, sampler##name, name##UV, name##UVLocal, name##_ST, objSpace, uvMapping, scale)
 
 //-----------------------------------------------------------------------------
 // GetSurfaceAndBuiltinData
     // Standard
     surfaceData.baseColor = SAMPLE_TEXTURE2D_SCALE_BIAS(_BaseColorMap).rgb * _BaseColor.rgb;
 
-    float4 gradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_NormalMap, _NormalScale);
+    float4 gradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_NormalMap, _NormalScale, _NormalMapObjSpace);
-    surfaceData.perceptualSmoothnessA = lerp(_SmoothnessARange.x, _SmoothnessARange.y, surfaceData.perceptualSmoothnessA);
+    surfaceData.perceptualSmoothnessA = lerp(_SmoothnessAMapRange.x, _SmoothnessAMapRange.y, surfaceData.perceptualSmoothnessA);
-    surfaceData.metallic = lerp(_MetallicRange.x, _MetallicRange.y, surfaceData.metallic);
+    surfaceData.metallic = lerp(_MetallicMapRange.x, _MetallicMapRange.y, surfaceData.metallic);
-    surfaceData.ambientOcclusion = lerp(_AmbientOcclusionRange.x, _AmbientOcclusionRange.y, surfaceData.ambientOcclusion);
+    surfaceData.ambientOcclusion = lerp(_AmbientOcclusionMapRange.x, _AmbientOcclusionMapRange.y, surfaceData.ambientOcclusion);
     surfaceData.ambientOcclusion = lerp(_AmbientOcclusion, surfaceData.ambientOcclusion, _AmbientOcclusionUseMap);
 
     // These static material feature allow compile time optimization
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_DUAL_SPECULAR_LOBE;
     surfaceData.lobeMix = _LobeMix;
     surfaceData.perceptualSmoothnessB = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_SmoothnessBMap), _SmoothnessBMapChannelMask);
-    surfaceData.perceptualSmoothnessB = lerp(_SmoothnessBRange.x, _SmoothnessBRange.y, surfaceData.perceptualSmoothnessB);
+    surfaceData.perceptualSmoothnessB = lerp(_SmoothnessBMapRange.x, _SmoothnessBMapRange.y, surfaceData.perceptualSmoothnessB);
     surfaceData.perceptualSmoothnessB = lerp(_SmoothnessB, surfaceData.perceptualSmoothnessB, _SmoothnessBUseMap);
 #else
     surfaceData.lobeMix = 0.0;
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_ANISOTROPY;
     // TODO: manage anistropy map
     //surfaceData.anisotropy = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_AnistropyMap), _AnistropyMapChannelMask);
-    //surfaceData.anisotropy = lerp(_AnistropyRange.x, _AnistropyRange.y, surfaceData.anisotropy);
+    //surfaceData.anisotropy = lerp(_AnistropyMapRange.x, _AnistropyMapRange.y, surfaceData.anisotropy);
     surfaceData.anisotropy = _Anisotropy; // In all cases we must multiply anisotropy with the map
 #else
     surfaceData.anisotropy = 0.0;
 #ifdef _MATERIAL_FEATURE_COAT
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_COAT;
     surfaceData.coatPerceptualSmoothness = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_CoatSmoothnessMap), _CoatSmoothnessMapChannelMask);
-    surfaceData.coatPerceptualSmoothness = lerp(_CoatSmoothnessRange.x, _CoatSmoothnessRange.y, surfaceData.coatPerceptualSmoothness);
+    surfaceData.coatPerceptualSmoothness = lerp(_CoatSmoothnessMapRange.x, _CoatSmoothnessMapRange.y, surfaceData.coatPerceptualSmoothness);
     surfaceData.coatPerceptualSmoothness = lerp(_CoatSmoothness, surfaceData.coatPerceptualSmoothness, _CoatSmoothnessUseMap);
     surfaceData.coatIor = _CoatIor;
     surfaceData.coatThickness = _CoatThickness;
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_COAT_NORMAL_MAP;
-    coatGradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_CoatNormalMap, _CoatNormalScale);
+    coatGradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_CoatNormalMap, _CoatNormalScale, _CoatNormalMapObjSpace);
 #endif
 
 #else
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_IRIDESCENCE;
     surfaceData.iridescenceIor = _IridescenceIor;
     surfaceData.iridescenceThickness = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_IridescenceThicknessMap), _IridescenceThicknessMapChannelMask);
-    surfaceData.iridescenceThickness = lerp(_IridescenceThicknessRange.x, _IridescenceThicknessRange.y, surfaceData.iridescenceThickness);
+    surfaceData.iridescenceThickness = lerp(_IridescenceThicknessMapRange.x, _IridescenceThicknessMapRange.y, surfaceData.iridescenceThickness);
-    surfaceData.iridescenceMask = lerp(_IridescenceMaskRange.x, _IridescenceMaskRange.y, surfaceData.iridescenceMask);
+    surfaceData.iridescenceMask = lerp(_IridescenceMaskMapRange.x, _IridescenceMaskMapRange.y, surfaceData.iridescenceMask);
     surfaceData.iridescenceMask = lerp(_IridescenceMask, surfaceData.iridescenceMask, _IridescenceMaskUseMap);
 
 #else
 #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_SUBSURFACE_SCATTERING;
     surfaceData.subsurfaceMask = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_SubsurfaceMaskMap), _SubsurfaceMaskMapChannelMask);
-    surfaceData.subsurfaceMask = lerp(_SubsurfaceMaskRange.x, _SubsurfaceMaskRange.y, surfaceData.subsurfaceMask);
+    surfaceData.subsurfaceMask = lerp(_SubsurfaceMaskMapRange.x, _SubsurfaceMaskMapRange.y, surfaceData.subsurfaceMask);
     surfaceData.subsurfaceMask = lerp(_SubsurfaceMask, surfaceData.subsurfaceMask, _SubsurfaceMaskUseMap);
 #else
     surfaceData.subsurfaceMask = 0.0;
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_STACK_LIT_TRANSMISSION;
     surfaceData.thickness = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_ThicknessMap), _ThicknessMapChannelMask);
-    surfaceData.thickness = lerp(_ThicknessRange.x, _ThicknessRange.y, surfaceData.thickness);
+    surfaceData.thickness = lerp(_ThicknessMapRange.x, _ThicknessMapRange.y, surfaceData.thickness);
+#ifdef _USE_DETAILMAP
+    float detailMask = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_DetailMaskMap), _DetailMaskMapChannelMask);
+
+    float4 detailGradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_DetailNormalMap, _DetailNormalScale, 0.0);
+    gradient += detailGradient * detailMask;
+    gradient.w *= 0.5; // Take mean of average normal length
+
+    float detailPerceptualSmoothness = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_DetailSmoothnessMap), _DetailSmoothnessMapChannelMask);
+    detailPerceptualSmoothness = lerp(_DetailSmoothnessMapRange.x, _DetailSmoothnessMapRange.y, detailPerceptualSmoothness);
+
+    // Use overlay blend mode for detail abledo: (base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)))
+    float smoothnessOverlay = (detailPerceptualSmoothness < 0.5) ?
+                                surfaceData.perceptualSmoothnessA * PositivePow(2.0 * detailPerceptualSmoothness, _DetailSmoothnessScale) :
+                                1.0 - (1.0 - surfaceData.perceptualSmoothnessA) * PositivePow(2.0 * (1.0 - detailPerceptualSmoothness), _DetailSmoothnessScale);
+    // Lerp with details mask
+    surfaceData.perceptualSmoothnessA = lerp(surfaceData.perceptualSmoothnessA, saturate(smoothnessOverlay), detailMask);
+
+    #ifdef _MATERIAL_FEATURE_DUAL_SPECULAR_LOBE
+   // Use overlay blend mode for detail abledo: (base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)))
+    smoothnessOverlay = (detailPerceptualSmoothness < 0.5) ?
+                                surfaceData.perceptualSmoothnessB * PositivePow(2.0 * detailPerceptualSmoothness, _DetailSmoothnessScale) :
+                                1.0 - (1.0 - surfaceData.perceptualSmoothnessB) * PositivePow(2.0 * (1.0 - detailPerceptualSmoothness), _DetailSmoothnessScale);
+    // Lerp with details mask
+    surfaceData.perceptualSmoothnessB = lerp(surfaceData.perceptualSmoothnessB, saturate(smoothnessOverlay), detailMask);
+    #endif
+#endif
     // -------------------------------------------------------------
     // Surface Data Part 2 (outsite GetSurfaceData( ) in Lit shader):
     // -------------------------------------------------------------
 
     builtinData.opacity = alpha;
 
-    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
+    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionRWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
 
     // It is safe to call this function here as surfaceData have been filled
     // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
         // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
         // TODO: optimize more this code.
         // Add GI transmission contribution by resampling the GI for inverted vertex normal
-        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
+        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionRWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
     }
 
     builtinData.emissiveColor = _EmissiveColor * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
     builtinData.velocity = float2(0.0, 0.0);
 
 #ifdef SHADOWS_SHADOWMASK
-    float4 shadowMask = SampleShadowMask(input.positionWS, input.texCoord1);
+    float4 shadowMask = SampleShadowMask(input.positionRWS, input.texCoord1);
     builtinData.shadowMask0 = shadowMask.x;
     builtinData.shadowMask1 = shadowMask.y;
     builtinData.shadowMask2 = shadowMask.z;

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

 TEXTURE2D(_ThicknessMap);
 SAMPLER(sampler_ThicknessMap);
 
+// Details
+TEXTURE2D(_DetailMaskMap);
+SAMPLER(sampler_DetailMaskMap);
+
+TEXTURE2D(_DetailSmoothnessMap);
+SAMPLER(sampler_DetailSmoothnessMap);
+
+TEXTURE2D(_DetailNormalMap);
+SAMPLER(sampler_DetailNormalMap);
+
 TEXTURE2D(_EmissiveColorMap);
 SAMPLER(sampler_EmissiveColorMap);
 
 float4 _MetallicMap_TexelSize;
 float4 _MetallicMap_MipInfo;
 float4 _MetallicMapChannelMask;
-float4 _MetallicRange;
+float4 _MetallicMapRange;
 
 float _DielectricIor;
 
 float4 _SmoothnessAMap_TexelSize;
 float4 _SmoothnessAMap_MipInfo;
 float4 _SmoothnessAMapChannelMask;
-float4 _SmoothnessARange;
+float4 _SmoothnessAMapRange;
 
 float4 _DebugEnvLobeMask;
 float4 _DebugLobeMask;
 float4 _AmbientOcclusionMap_TexelSize;
 float4 _AmbientOcclusionMap_MipInfo;
 float4 _AmbientOcclusionMapChannelMask;
-float4 _AmbientOcclusionRange;
+float4 _AmbientOcclusionMapRange;
 
 float _SmoothnessB;
 float _SmoothnessBUseMap;
 float4 _SmoothnessBMap_TexelSize;
 float4 _SmoothnessBMap_MipInfo;
 float4 _SmoothnessBMapChannelMask;
-float4 _SmoothnessBRange;
+float4 _SmoothnessBMapRange;
 float _LobeMix;
 
 float _Anisotropy;
 float4 _AnisotropyMap_TexelSize;
 float4 _AnisotropyMap_MipInfo;
 float4 _AnisotropyMapChannelMask;
-float4 _AnisotropyRange;
+float4 _AnisotropyMapRange;
 
 float _CoatSmoothness;
 float _CoatSmoothnessUseMap;
 float4 _CoatSmoothnessMap_TexelSize;
 float4 _CoatSmoothnessMap_MipInfo;
 float4 _CoatSmoothnessMapChannelMask;
-float4 _CoatSmoothnessRange;
+float4 _CoatSmoothnessMapRange;
 float _CoatIor;
 float _CoatThickness;
 float3 _CoatExtinction;
 float4 _CoatNormalMap_TexelSize;
 float4 _CoatNormalMap_MipInfo;
 
-
 float _IridescenceThickness;
 float _IridescenceThicknessUseMap;
 float _IridescenceThicknessMapUV;
 float4 _IridescenceThicknessMap_MipInfo;
 float4 _IridescenceThicknessMapChannelMask;
-float4 _IridescenceThicknessRange;
+float4 _IridescenceThicknessMapRange;
 float _IridescenceIor;
 
 float _IridescenceMask;
 float4 _IridescenceMaskMap_TexelSize;
 float4 _IridescenceMaskMap_MipInfo;
 float4 _IridescenceMaskMapChannelMask;
-float4 _IridescenceMaskRange;
+float4 _IridescenceMaskMapRange;
 
 int _DiffusionProfile;
 float _SubsurfaceMask;
 float4 _SubsurfaceMaskMap_TexelSize;
 float4 _SubsurfaceMaskMap_MipInfo;
 float4 _SubsurfaceMaskMapChannelMask;
-float4 _SubsurfaceMaskRange;
+float4 _SubsurfaceMaskMapRange;
 
 float _Thickness;
 float _ThicknessUseMap;
 float4 _ThicknessMap_TexelSize;
 float4 _ThicknessMap_MipInfo;
 float4 _ThicknessMapChannelMask;
-float4 _ThicknessRange;
+float4 _ThicknessMapRange;
+
+// Details
+float _DetailMaskMapUV;
+float _DetailMaskMapUVLocal;
+float4 _DetailMaskMap_ST;
+float4 _DetailMaskMap_TexelSize;
+float4 _DetailMaskMap_MipInfo;
+float4 _DetailMaskMapChannelMask;
+
+float _DetailSmoothnessMapUV;
+float _DetailSmoothnessMapUVLocal;
+float4 _DetailSmoothnessMap_ST;
+float4 _DetailSmoothnessMap_TexelSize;
+float4 _DetailSmoothnessMap_MipInfo;
+float4 _DetailSmoothnessMapChannelMask;
+float4 _DetailSmoothnessMapRange;
+float _DetailSmoothnessScale;
+
+float _DetailNormalScale;
+float _DetailNormalMapUV;
+float _DetailNormalMapUVLocal;
+float4 _DetailNormalMap_ST;
+float4 _DetailNormalMap_TexelSize;
+float4 _DetailNormalMap_MipInfo;
+
 
 float3 _EmissiveColor;
 float4 _EmissiveColorMap_ST;

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/CopyDepthBuffer.shader

             #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../ShaderVariables.hlsl"
 
-            TEXTURE2D(_InputDepthTexture);
+            TEXTURE2D_FLOAT(_InputDepthTexture);
 
             struct Attributes
             {

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/FragInputs.hlsl

     // Contain value return by SV_POSITION (That is name positionCS in PackedVarying).
     // xy: unormalized screen position (offset by 0.5), z: device depth, w: depth in view space
     // Note: SV_POSITION is the result of the clip space position provide to the vertex shaders that is transform by the viewport
-    float4 positionSS; // In case depth offset is use, positionWS.w is equal to depth offset
-    float3 positionWS;
+    float4 positionSS; // In case depth offset is use, positionRWS.w is equal to depth offset
+    float3 positionRWS; // Relative camera space position
     float2 texCoord0;
     float2 texCoord1;
     float2 texCoord2;

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassDBuffer.hlsl

 {
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 	DecalSurfaceData surfaceData;
-  
+
-    // Transform from world space to decal space (DS) to clip the decal.
-    // For this we must use absolute position.
-    // There is no lose of precision here as it doesn't involve the camera matrix
-    float3 positionWS = GetAbsolutePositionWS(posInput.positionWS);
-    float3 positionDS = mul(UNITY_MATRIX_I_M, float4(positionWS, 1.0)).xyz;
+    // Transform from relative world space to decal space (DS) to clip the decal
+    float3 positionDS = TransformWorldToObject(posInput.positionWS);
-    
+
     float4x4 normalToWorld = UNITY_ACCESS_INSTANCED_PROP(matrix, _NormalToWorld);
     GetSurfaceData(positionDS.xz, normalToWorld, surfaceData);
 	// have to do explicit test since compiler behavior is not defined for RW resources and discard instructions

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassDepthOnly.hlsl

     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassDistortion.hlsl

     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassForward.hlsl

     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS.xyz, uint2(input.positionSS.xy) / GetTileSize());
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS.xyz, uint2(input.positionSS.xy) / GetTileSize());
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassForwardUnlit.hlsl

     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassGBuffer.hlsl

     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassLightTransport.hlsl

     output.vmesh.positionCS = float4(uv * 2.0 - 1.0, inputMesh.positionOS.z > 0 ? 1.0e-4 : 0.0, 1.0);
 
 #ifdef VARYINGS_NEED_POSITION_WS
-    float3 positionWS = GetCameraRelativePositionWS(TransformObjectToWorld(inputMesh.positionOS));
-    output.vmesh.positionWS = positionWS;
+    output.vmesh.positionRWS = TransformObjectToWorld(inputMesh.positionOS);
 #endif
 
 #ifdef VARYINGS_NEED_TANGENT_TO_WORLD
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassVelocity.hlsl

 #endif
 }
 
+// Transforms local position to camera relative world space
+float3 TransformPreviousObjectToWorld(float3 positionOS)
+{
+    float4x4 previousModelMatrix = ApplyCameraTranslationToMatrix(unity_MatrixPreviousM);
+    return mul(previousModelMatrix, float4(positionOS, 1.0)).xyz;
+}
+
 void VelocityPositionZBias(VaryingsToPS input)
 {
 #if defined(UNITY_REVERSED_Z)
     // It is not possible to correctly generate the motion vector for tesselated geometry as tessellation parameters can change
     // from one frame to another (adaptative, lod) + in Unity we only receive information for one non tesselated vertex.
     // So motion vetor will be based on interpolate previous position at vertex level instead.
-    varyingsType.vpass.positionCS = mul(_NonJitteredViewProjMatrix, float4(varyingsType.vmesh.positionWS, 1.0));
+    varyingsType.vpass.positionCS = mul(_NonJitteredViewProjMatrix, float4(varyingsType.vmesh.positionRWS, 1.0));
 
     // Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
     bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
         if (hasDeformation)
             previousMesh.positionOS = inputPass.previousPositionOS;
         previousMesh = ApplyMeshModification(previousMesh);
-        float3 previousPositionWS = mul(unity_MatrixPreviousM, float4(previousMesh.positionOS, 1.0)).xyz;
+        float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.positionOS);
-        float3 previousPositionWS = mul(unity_MatrixPreviousM, hasDeformation ? float4(inputPass.previousPositionOS, 1.0) : float4(inputMesh.positionOS, 1.0)).xyz;
+        float3 previousPositionRWS = TransformPreviousObjectToWorld(hasDeformation ? inputPass.previousPositionOS : inputMesh.positionOS);
 #endif
 
 #ifdef ATTRIBUTES_NEED_NORMAL
 #endif
 
  #if defined(HAVE_VERTEX_MODIFICATION)
-        ApplyVertexModification(inputMesh, normalWS, previousPositionWS, _LastTime);
+        ApplyVertexModification(inputMesh, normalWS, previousPositionRWS, _LastTime);
-        //Need this since we are using the current position from VertMesh()
-        previousPositionWS = GetCameraRelativePositionWS(previousPositionWS);
-
-        varyingsType.vpass.previousPositionCS = mul(_PrevViewProjMatrix, float4(previousPositionWS, 1.0));
+        varyingsType.vpass.previousPositionCS = mul(_PrevViewProjMatrix, float4(previousPositionRWS, 1.0));
     }
 
     return PackVaryingsType(varyingsType);
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
     // input.positionSS is SV_Position
-    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
-    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
     float3 V = 0; // Avoid the division by 0
 #endif

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/TessellationShare.hlsl

     VaryingsToDS varying1 = UnpackVaryingsToDS(input[1]);
     VaryingsToDS varying2 = UnpackVaryingsToDS(input[2]);
 
-    float3 p0 = varying0.vmesh.positionWS;
-    float3 p1 = varying1.vmesh.positionWS;
-    float3 p2 = varying2.vmesh.positionWS;
+    float3 p0 = varying0.vmesh.positionRWS;
+    float3 p1 = varying1.vmesh.positionRWS;
+    float3 p2 = varying2.vmesh.positionRWS;
 
     float3 n0 = varying0.vmesh.normalWS;
     float3 n1 = varying1.vmesh.normalWS;
     // We have Phong tessellation in all case where we don't have displacement only
 #ifdef _TESSELLATION_PHONG
 
-    float3 p0 = varying0.vmesh.positionWS;
-    float3 p1 = varying1.vmesh.positionWS;
-    float3 p2 = varying2.vmesh.positionWS;
+    float3 p0 = varying0.vmesh.positionRWS;
+    float3 p1 = varying1.vmesh.positionRWS;
+    float3 p2 = varying2.vmesh.positionRWS;
-    varying.vmesh.positionWS = PhongTessellation(   varying.vmesh.positionWS,
+    varying.vmesh.positionRWS = PhongTessellation(  varying.vmesh.positionRWS,
-    ApplyTessellationModification(varying.vmesh, varying.vmesh.normalWS, varying.vmesh.positionWS);
+    ApplyTessellationModification(varying.vmesh, varying.vmesh.normalWS, varying.vmesh.positionRWS);
 #endif
 
     return VertTesselation(varying);

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/VaryingMesh.hlsl

 {
     float4 positionCS;
 #ifdef VARYINGS_NEED_POSITION_WS
-    float3 positionWS;
+    float3 positionRWS;
 #endif
 #ifdef VARYINGS_NEED_TANGENT_TO_WORLD
     float3 normalWS;
     output.positionCS = input.positionCS;
 
 #ifdef VARYINGS_NEED_POSITION_WS
-    output.interpolators0 = input.positionWS;
+    output.interpolators0 = input.positionRWS;
 #endif
 
 #ifdef VARYINGS_NEED_TANGENT_TO_WORLD
     output.positionSS = input.positionCS; // input.positionCS is SV_Position
 
 #ifdef VARYINGS_NEED_POSITION_WS
-    output.positionWS.xyz = input.interpolators0.xyz;
+    output.positionRWS.xyz = input.interpolators0.xyz;
 #endif
 
 #ifdef VARYINGS_NEED_TANGENT_TO_WORLD
 // Position and normal are always present (for tessellation) and in world space
 struct VaryingsMeshToDS
 {
-    float3 positionWS;
+    float3 positionRWS;
     float3 normalWS;
 #ifdef VARYINGS_DS_NEED_TANGENT
     float4 tangentWS;
 
 struct PackedVaryingsMeshToDS
 {
-    float3 interpolators0 : INTERNALTESSPOS; // positionWS
+    float3 interpolators0 : INTERNALTESSPOS; // positionRWS
     float3 interpolators1 : NORMAL; // NormalWS
 
 #ifdef VARYINGS_DS_NEED_TANGENT
 
     UNITY_TRANSFER_INSTANCE_ID(input, output);
 
-    output.interpolators0 = input.positionWS;
+    output.interpolators0 = input.positionRWS;
     output.interpolators1 = input.normalWS;
 #ifdef VARYINGS_DS_NEED_TANGENT
     output.interpolators2 = input.tangentWS;
 
     UNITY_TRANSFER_INSTANCE_ID(input, output);
 
-    output.positionWS = input.interpolators0;
+    output.positionRWS = input.interpolators0;
     output.normalWS = input.interpolators1;
 #ifdef VARYINGS_DS_NEED_TANGENT
     output.tangentWS = input.interpolators2;
 
     UNITY_TRANSFER_INSTANCE_ID(input0, output);
 
-    TESSELLATION_INTERPOLATE_BARY(positionWS, baryCoords);
+    TESSELLATION_INTERPOLATE_BARY(positionRWS, baryCoords);
     TESSELLATION_INTERPOLATE_BARY(normalWS, baryCoords);
 #ifdef VARYINGS_DS_NEED_TANGENT
     // This will interpolate the sign but should be ok in practice as we may expect a triangle to have same sign (? TO CHECK)

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/VertMesh.hlsl

     UNITY_SETUP_INSTANCE_ID(input);
     UNITY_TRANSFER_INSTANCE_ID(input, output);
 
-    float3 positionWS = TransformObjectToWorld(input.positionOS);
+    // This return the camera relative position (if enable)
+    float3 positionRWS = TransformObjectToWorld(input.positionOS);
 #ifdef ATTRIBUTES_NEED_NORMAL
     float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
 #else
      float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
 #endif
 
-    // TODO: deal with camera center rendering and instancing (This is the reason why we always perform two  steps transform to clip space + instancing matrix)
-
+     // Do vertex modification in camera relative space (if enable)
-    ApplyVertexModification(input, normalWS, positionWS, _Time);
+    ApplyVertexModification(input, normalWS, positionRWS, _Time);
-    positionWS = GetCameraRelativePositionWS(positionWS);
-
-    output.positionWS = positionWS;
+    output.positionRWS = positionRWS;
     output.normalWS = normalWS;
     #if defined(VARYINGS_NEED_TANGENT_TO_WORLD) || defined(VARYINGS_DS_NEED_TANGENT)
     output.tangentWS = tangentWS;
-    output.positionWS = positionWS;
+    output.positionRWS = positionRWS;
-    output.positionCS = TransformWorldToHClip(positionWS);
+    output.positionCS = TransformWorldToHClip(positionRWS);
     #ifdef VARYINGS_NEED_TANGENT_TO_WORLD
     output.normalWS = normalWS;
     output.tangentWS = tangentWS;
     UNITY_SETUP_INSTANCE_ID(input);
     UNITY_TRANSFER_INSTANCE_ID(input, output);
 
-    output.positionCS = TransformWorldToHClip(input.positionWS);
+    output.positionCS = TransformWorldToHClip(input.positionRWS);
-    output.positionWS = input.positionWS;
+    output.positionRWS = input.positionRWS;
 #endif
 
 #ifdef VARYINGS_NEED_TANGENT_TO_WORLD

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

     return M;
 }
 
+// Helper to handle camera relative space
+
+float4x4 ApplyCameraTranslationToMatrix(float4x4 modelMatrix)
+{
+    // To handle camera relative rendering we substract the camera position in the model matrix
+    // User must not use UNITY_MATRIX_M directly, unless they understand what they do
+#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+    modelMatrix._m03_m13_m23 -= _WorldSpaceCameraPos;
+#endif
+    return modelMatrix;
+}
+
+float4x4 ApplyCameraTranslationToInverseMatrix(float4x4 inverseModelMatrix)
+{
+#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+    // To handle camera relative rendering we need to apply translation before converting to object space
+    float4x4 translationMatrix = { { 1.0, 0.0, 0.0, _WorldSpaceCameraPos.x },{ 0.0, 1.0, 0.0, _WorldSpaceCameraPos.y },{ 0.0, 0.0, 1.0, _WorldSpaceCameraPos.z },{ 0.0, 0.0, 0.0, 1.0 } };
+    return mul(inverseModelMatrix, translationMatrix);
+#else
+    return inverseModelMatrix;
+#endif
+}
+
 #ifdef USE_LEGACY_UNITY_MATRIX_VARIABLES
     #include "ShaderVariablesMatrixDefsLegacyUnity.hlsl"
 #else
+
+// This define allow to tell to unity instancing that we will use our camera relative functions (ApplyCameraTranslationToMatrix and  ApplyCameraTranslationToInverseMatrix) for the model view matrix
+#define MODIFY_MATRIX_FOR_CAMERA_RELATIVE_RENDERING
 #include "CoreRP/ShaderLibrary/UnityInstancing.hlsl"
 #include "ShaderVariablesFunctions.hlsl"
 

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

 #ifndef UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED
 #define UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED
 
+// This function always return the absolute position in WS
+float3 GetAbsolutePositionWS(float3 positionRWS)
+{
+#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+    positionRWS += _WorldSpaceCameraPos;
+#endif
+    return positionRWS;
+}
+
+// This function return the camera relative position in WS
+float3 GetCameraRelativePositionWS(float3 positionWS)
+{
+#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+    positionWS -= _WorldSpaceCameraPos;
+#endif
+    return positionWS;
+}
+
+// Return absolute world position of current object
+float3 GetObjectAbsolutePositionWS()
+{
+    float4x4 modelMatrix = UNITY_MATRIX_M;
+    return GetAbsolutePositionWS(modelMatrix._m03_m13_m23); // Translation object to world
+}
+
+// Return the PreTranslated ObjectToWorld Matrix (i.e matrix with _WorldSpaceCameraPos apply to it if we use camera relative rendering)
 float4x4 GetObjectToWorldMatrix()
 {
     return UNITY_MATRIX_M;
     return unity_WorldTransformParams.w;
 }
 
-float3 TransformWorldToView(float3 positionWS)
+float3 TransformWorldToView(float3 positionRWS)
-    return mul(GetWorldToViewMatrix(), float4(positionWS, 1.0)).xyz;
+    return mul(GetWorldToViewMatrix(), float4(positionRWS, 1.0)).xyz;
 }
 
 float3 TransformObjectToWorld(float3 positionOS)
 
-float3 TransformWorldToObject(float3 positionWS)
+float3 TransformWorldToObject(float3 positionRWS)
-    return mul(GetWorldToObjectMatrix(), float4(positionWS, 1.0)).xyz;
+    return mul(GetWorldToObjectMatrix(), float4(positionRWS, 1.0)).xyz;
 }
 
 float3 TransformObjectToWorldDir(float3 dirOS)
 }
 
 // Tranforms position from world space to homogenous space
-float4 TransformWorldToHClip(float3 positionWS)
+float4 TransformWorldToHClip(float3 positionRWS)
-    return mul(GetWorldToHClipMatrix(), float4(positionWS, 1.0));
+    return mul(GetWorldToHClipMatrix(), float4(positionRWS, 1.0));
 }
 
 // Tranforms vector from world space to homogenous space
     return mul((float3x3)GetViewToHClipMatrix(), directionVS);
 }
 
-// This function always return the absolute position in WS either the CameraRelative mode is enabled or not
-float3 GetAbsolutePositionWS(float3 positionWS)
-{
-#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
-    positionWS += _WorldSpaceCameraPos;
-#endif
-    return positionWS;
-}
-
-// This function always return the camera relative position in WS either the CameraRelative mode is enabled or not
-float3 GetCameraRelativePositionWS(float3 positionWS)
-{
-#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
-    positionWS -= _WorldSpaceCameraPos;
-#endif
-    return positionWS;
-}
-
 float3 GetPrimaryCameraPosition()
 {
 #if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
 }
 
 // Computes the world space view direction (pointing towards the viewer).
-float3 GetWorldSpaceViewDir(float3 positionWS)
+float3 GetWorldSpaceViewDir(float3 positionRWS)
-        return GetCurrentViewPosition() - positionWS;
+        return GetCurrentViewPosition() - positionRWS;
     }
     else
     {
 }
 
-float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
+float3 GetWorldSpaceNormalizeViewDir(float3 positionRWS)
-    return normalize(GetWorldSpaceViewDir(positionWS));
+    return normalize(GetWorldSpaceViewDir(positionRWS));
 }
 
 float3x3 CreateWorldToTangent(float3 normal, float3 tangent, float flipSign)

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

 #ifndef UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED
 #define UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED
 
+#define UNITY_MATRIX_M     ApplyCameraTranslationToMatrix(unity_ObjectToWorld)
+#define UNITY_MATRIX_I_M   ApplyCameraTranslationToInverseMatrix(unity_WorldToObject)
+
-#define UNITY_MATRIX_M     unity_ObjectToWorld
-#define UNITY_MATRIX_I_M   unity_WorldToObject
 #define UNITY_MATRIX_V     _ViewMatrixStereo[unity_StereoEyeIndex]
 #define UNITY_MATRIX_I_V   _InvViewMatrixStereo[unity_StereoEyeIndex]
 #define UNITY_MATRIX_P     OptimizeProjectionMatrix(unity_StereoMatrixP[unity_StereoEyeIndex])
 
 #else
 
-#define UNITY_MATRIX_M     unity_ObjectToWorld
-#define UNITY_MATRIX_I_M   unity_WorldToObject
 #define UNITY_MATRIX_V     _ViewMatrix
 #define UNITY_MATRIX_I_V   _InvViewMatrix
 #define UNITY_MATRIX_P     OptimizeProjectionMatrix(_ProjMatrix)

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

 #ifndef UNITY_SHADER_VARIABLES_MATRIX_DEFS_LEGACY_UNITY_INCLUDED
 #define UNITY_SHADER_VARIABLES_MATRIX_DEFS_LEGACY_UNITY_INCLUDED
 
-#define UNITY_MATRIX_M     unity_ObjectToWorld
-#define UNITY_MATRIX_I_M   unity_WorldToObject
+#define UNITY_MATRIX_M     ApplyCameraTranslationToMatrix(unity_ObjectToWorld)
+#define UNITY_MATRIX_I_M   ApplyCameraTranslationToInverseMatrix(unity_WorldToObject)
 #define UNITY_MATRIX_V     unity_MatrixV
 #define UNITY_MATRIX_I_V   unity_MatrixInvV
 #define UNITY_MATRIX_P     OptimizeProjectionMatrix(glstate_matrix_projection)

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs

 using System.Linq;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.LightweightPipeline;
 
 namespace UnityEditor.Experimental.Rendering.LightweightPipeline
 {
             }
 
             return subShader.ToString();
+        }
+
+        public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
+        {
+            return renderPipelineAsset is LightweightPipelineAsset;
         }
 
         static string GetTemplatePath(string templateName)

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs

 using System.IO;
 using System.Linq;
 using UnityEditor;
-using UnityEditor.Experimental.Rendering.LightweightPipeline;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph;
 
             }
 
             return subShader.ToString();
+        }
+
+        public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
+        {
+            return renderPipelineAsset is LightweightPipelineAsset;
         }
 
         static string GetTemplatePath(string templateName)

com.unity.shadergraph/CHANGELOG.md

 - Deserialization of subgraphs now works correctly.
 - Sub graphs are now suffixed with (sub), so you can tell them apart from other nodes.
 - The preview of a node does not obstruct the selection outliner anymore.
+- If the current render pipeline is not compatible, master nodes now display an error badge.
+- The preview shader now only considers the current render pipeline. Because of this there is less code to compile, and therefore the preview shader will compile faster.
+- When you rename a shader graph or sub shader graph locally on your disk, the title of the Shader Graph window, black board, and preview also updates.

com.unity.shadergraph/Editor/Data/MasterNodes/ISubShader.cs

 using System;
 using System.Collections.Generic;
+using UnityEngine.Experimental.Rendering;
 
 namespace UnityEditor.ShaderGraph
 {
+        bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset);
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/IMasterNode.cs

     public interface IMasterNode : INode
     {
         string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths = null);
-        bool IsPipelineCompatible(IRenderPipeline renderPipeline);
+        bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset);
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/MasterNode.cs

 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.UIElements;
+using UnityEngine.Rendering;
 
 namespace UnityEditor.ShaderGraph
 {
                 }
 
                 foreach (var subShader in m_SubShaders)
-                    finalShader.AppendLines(subShader.GetSubshader(this, mode, sourceAssetDependencyPaths));
+                {
+                    if (mode != GenerationMode.Preview || subShader.IsPipelineCompatible(GraphicsSettings.renderPipelineAsset))
+                        finalShader.AppendLines(subShader.GetSubshader(this, mode, sourceAssetDependencyPaths));
+                }
 
                 finalShader.AppendLine(@"FallBack ""Hidden/InternalErrorShader""");
             }
 
-        public bool IsPipelineCompatible(IRenderPipeline renderPipeline)
+        public bool IsPipelineCompatible(RenderPipelineAsset renderPipelineAsset)
-            return true;
+            foreach (var subShader in m_SubShaders)
+            {
+                if (subShader.IsPipelineCompatible(GraphicsSettings.renderPipelineAsset))
+                    return true;
+            }
+            return false;
         }
 
         public override void OnBeforeSerialize()

com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardProvider.cs

         //    set { m_ResizeBorderFrame.OnResizeFinished = value; }
         //}
 
-        public BlackboardProvider(string assetName, AbstractMaterialGraph graph)
+        public string assetName
+        {
+            get { return blackboard.title; }
+            set
+            {
+                blackboard.title = value;
+            }
+        }
+
+        public BlackboardProvider(AbstractMaterialGraph graph)
         {
             m_Graph = graph;
             m_ExposedIcon = Resources.Load<Texture2D>("GraphView/Nodes/BlackboardFieldExposed");
             {
                 scrollable = true,
-                title = assetName.Split('/').Last(),
                 subTitle = FormatPath(graph.path),
                 editTextRequested = EditTextRequested,
                 addItemRequested = AddItemRequested,

com.unity.shadergraph/Editor/Drawing/Inspector/MasterPreviewView.cs

         }
 
         VisualElement m_Preview;
+        Label m_Title;
 
         public VisualElement preview
         {
         static Type s_ContextualMenuManipulator = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypesOrNothing()).FirstOrDefault(t => t.FullName == "UnityEngine.Experimental.UIElements.ContextualMenuManipulator");
         static Type s_ObjectSelector = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypesOrNothing()).FirstOrDefault(t => t.FullName == "UnityEditor.ObjectSelector");
 
-        public MasterPreviewView(string assetName, PreviewManager previewManager, AbstractMaterialGraph graph)
+        public string assetName
+        {
+            get { return m_Title.text; }
+            set { m_Title.text = value; }
+        }
+
+        public MasterPreviewView(PreviewManager previewManager, AbstractMaterialGraph graph)
         {
             this.clippingOptions = ClippingOptions.ClipAndCacheContents;
             m_PreviewManager = previewManager;
 
             var topContainer = new VisualElement() { name = "top" };
             {
-                var title = new Label(assetName.Split('/').Last()) { name = "title" };
+                m_Title = new Label() { name = "title" };
 
                 // Add preview collapse button on top of preview
                 m_CollapsePreviewContainer = new VisualElement { name = "collapse-container" };
                         UpdatePreviewVisibility();
                     }));
 
-                topContainer.Add(title);
+                topContainer.Add(m_Title);
                 topContainer.Add(m_CollapsePreviewContainer);
             }
             Add(topContainer);

com.unity.shadergraph/Editor/Drawing/MaterialGraphEditWindow.cs

 using Object = UnityEngine.Object;
 using Edge = UnityEditor.Experimental.UIElements.GraphView.Edge;
 using UnityEditor.Experimental.UIElements.GraphView;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering;
 
 namespace UnityEditor.ShaderGraph.Drawing
 {
         public bool forceRedrawPreviews = false;
 
         ColorSpace m_ColorSpace;
+        RenderPipelineAsset m_RenderPipelineAsset;
 
         GraphEditorView m_GraphEditorView;
 
             private set { m_Selected = value; }
         }
 
+        public string assetName
+        {
+            get { return titleContent.text; }
+            set
+            {
+                titleContent.text = value;
+                graphEditorView.assetName = value;
+            }
+        }
+
         void Update()
         {
             if (m_HasError)
                 m_ColorSpace = PlayerSettings.colorSpace;
             }
 
+            if (GraphicsSettings.renderPipelineAsset != m_RenderPipelineAsset)
+            {
+                graphEditorView = null;
+                m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
+            }
+
             try
             {
                 if (graphObject == null && selectedGuid != null)
                 var materialGraph = graphObject.graph as AbstractMaterialGraph;
                 if (materialGraph == null)
                     return;
+
-                    graphEditorView = new GraphEditorView(this, materialGraph, asset.name) { persistenceKey = selectedGuid };
+                    graphEditorView = new GraphEditorView(this, materialGraph)
+                    {
+                        persistenceKey = selectedGuid,
+                        assetName = asset.name.Split('/').Last()
+                    };
+                    m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
                 }
 
                 if (forceRedrawPreviews)
             try
             {
                 m_ColorSpace = PlayerSettings.colorSpace;
+                m_RenderPipelineAsset = GraphicsSettings.renderPipelineAsset;
 
                 var asset = AssetDatabase.LoadAssetAtPath<Object>(AssetDatabase.GUIDToAssetPath(assetGuid));
                 if (asset == null)
                 graphObject.graph.OnEnable();
                 graphObject.graph.ValidateGraph();
 
-                graphEditorView = new GraphEditorView(this, m_GraphObject.graph as AbstractMaterialGraph, asset.name) { persistenceKey = selectedGuid };
+                graphEditorView = new GraphEditorView(this, m_GraphObject.graph as AbstractMaterialGraph)
+                {
+                    persistenceKey = selectedGuid,
+                    assetName = asset.name.Split('/').Last()
+                };
-                titleContent = new GUIContent(asset.name);
+                titleContent = new GUIContent(asset.name.Split('/').Last());
 
                 Repaint();
             }

com.unity.shadergraph/Editor/Drawing/Views/GraphEditorView.cs

             set { m_PreviewManager = value; }
         }
 
-        public GraphEditorView(EditorWindow editorWindow, AbstractMaterialGraph graph, string assetName)
+        public string assetName
+        {
+            get { return m_BlackboardProvider.assetName; }
+            set
+            {
+                m_BlackboardProvider.assetName = value;
+                m_MasterPreviewView.assetName = value;
+            }
+        }
+
+        public GraphEditorView(EditorWindow editorWindow, AbstractMaterialGraph graph)
         {
             m_Graph = graph;
             AddStyleSheetPath("Styles/GraphEditorView");
 
             var content = new VisualElement { name = "content" };
             {
-                graph.name = assetName;
                 m_GraphView = new MaterialGraphView(graph) { name = "GraphView", persistenceKey = "MaterialGraphView" };
                 m_GraphView.SetupZoom(0.05f, ContentZoomer.DefaultMaxScale);
                 m_GraphView.AddManipulator(new ContentDragger());
                 m_GraphView.RegisterCallback<KeyDownEvent>(OnSpaceDown);
                 content.Add(m_GraphView);
 
-                m_BlackboardProvider = new BlackboardProvider(assetName, graph);
+                m_BlackboardProvider = new BlackboardProvider(graph);
                 m_GraphView.Add(m_BlackboardProvider.blackboard);
                 Rect blackboardLayout = m_BlackboardProvider.blackboard.layout;
                 blackboardLayout.x = 10f;
-                m_MasterPreviewView = new MasterPreviewView(assetName, previewManager, graph) { name = "masterPreview" };
+                m_MasterPreviewView = new MasterPreviewView(previewManager, graph) { name = "masterPreview" };
 
                 WindowDraggable masterPreviewViewDraggable = new WindowDraggable(null, this);
                 m_MasterPreviewView.AddManipulator(masterPreviewViewDraggable);

com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs

 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.UIElements.StyleEnums;
 using UnityEngine.Experimental.UIElements.StyleSheets;
+using UnityEngine.Rendering;
 using Node = UnityEditor.Experimental.UIElements.GraphView.Node;
 
 namespace UnityEditor.ShaderGraph.Drawing
             var masterNode = node as IMasterNode;
             if (masterNode != null)
             {
-                if (!masterNode.IsPipelineCompatible(RenderPipelineManager.currentPipeline))
+                if (!masterNode.IsPipelineCompatible(GraphicsSettings.renderPipelineAsset))
-                    IconBadge wrongPipeline = IconBadge.CreateError("The current render pipeline is not compatible with this node preview.");
+                    IconBadge wrongPipeline = IconBadge.CreateError("The current render pipeline is not compatible with this master node.");
                     Add(wrongPipeline);
                     VisualElement title = this.Q("title");
                     wrongPipeline.AttachTo(title, SpriteAlignment.LeftCenter);

com.unity.shadergraph/Editor/Importers/ShaderGraphImporter.cs

 using UnityEditor.Experimental.AssetImporters;
 using UnityEditor.ShaderGraph.Drawing;
 
-[ScriptedImporter(15, ShaderGraphExtension)]
-public class ShaderGraphImporter : ScriptedImporter
+namespace UnityEditor.ShaderGraph
-    public const string ShaderGraphExtension = "shadergraph";
+    [ScriptedImporter(15, ShaderGraphExtension)]
+    public class ShaderGraphImporter : ScriptedImporter
+    {
+        public const string ShaderGraphExtension = "shadergraph";
-    const string k_ErrorShader = @"
+        const string k_ErrorShader = @"
 Shader ""Hidden/GraphErrorShader2""
 {
     SubShader
     Fallback Off
 }";
 
-
-    public override void OnImportAsset(AssetImportContext ctx)
-    {
-        var oldShader = AssetDatabase.LoadAssetAtPath<Shader>(ctx.assetPath);
-        if (oldShader != null)
-            ShaderUtil.ClearShaderErrors(oldShader);
+        public override void OnImportAsset(AssetImportContext ctx)
+        {
+            var oldShader = AssetDatabase.LoadAssetAtPath<Shader>(ctx.assetPath);
+            if (oldShader != null)
+                ShaderUtil.ClearShaderErrors(oldShader);
-        List<PropertyCollector.TextureInfo> configuredTextures;
-        string path = ctx.assetPath;
-        var sourceAssetDependencyPaths = new List<string>();
-        var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths);
-        var shader = ShaderUtil.CreateShaderAsset(text);
+            List<PropertyCollector.TextureInfo> configuredTextures;
+            string path = ctx.assetPath;
+            var sourceAssetDependencyPaths = new List<string>();
+            var text = GetShaderText(path, out configuredTextures, sourceAssetDependencyPaths);
+            var shader = ShaderUtil.CreateShaderAsset(text);
-        EditorMaterialUtility.SetShaderDefaults(
-            shader,
-            configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
-            configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
-        EditorMaterialUtility.SetShaderNonModifiableDefaults(
-            shader,
-            configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
-            configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
+            EditorMaterialUtility.SetShaderDefaults(
+                shader,
+                configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
+                configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
+            EditorMaterialUtility.SetShaderNonModifiableDefaults(
+                shader,
+                configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
+                configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
-        ctx.AddObjectToAsset("MainAsset", shader);
-        ctx.SetMainObject(shader);
+            ctx.AddObjectToAsset("MainAsset", shader);
+            ctx.SetMainObject(shader);
-        foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
-            ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
-    }
+            foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
+                ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
+        }
-    internal static string GetShaderText(string path, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths)
-    {
-        string shaderString = null;
-        var shaderName = Path.GetFileNameWithoutExtension(path);
-        try
+        internal static string GetShaderText(string path, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths)
-            var textGraph = File.ReadAllText(path, Encoding.UTF8);
-            var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
-            graph.LoadedFromDisk();
+            string shaderString = null;
+            var shaderName = Path.GetFileNameWithoutExtension(path);
+            try
+            {
+                var textGraph = File.ReadAllText(path, Encoding.UTF8);
+                var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
+                graph.LoadedFromDisk();
-            if (!string.IsNullOrEmpty(graph.path))
-                shaderName = graph.path + "/" + shaderName;
-            shaderString = graph.GetShader(shaderName, GenerationMode.ForReals, out configuredTextures, sourceAssetDependencyPaths);
+                if (!string.IsNullOrEmpty(graph.path))
+                    shaderName = graph.path + "/" + shaderName;
+                shaderString = graph.GetShader(shaderName, GenerationMode.ForReals, out configuredTextures, sourceAssetDependencyPaths);
-            if (sourceAssetDependencyPaths != null)
+                if (sourceAssetDependencyPaths != null)
+                {
+                    foreach (var node in graph.GetNodes<AbstractMaterialNode>())
+                        node.GetSourceAssetDependencies(sourceAssetDependencyPaths);
+                }
+            }
+            catch (Exception)
-                foreach (var node in graph.GetNodes<AbstractMaterialNode>())
-                    node.GetSourceAssetDependencies(sourceAssetDependencyPaths);
+                configuredTextures = new List<PropertyCollector.TextureInfo>();
+
+                // ignored
-        }
-        catch (Exception)
-        {
-            configuredTextures = new List<PropertyCollector.TextureInfo>();
-            // ignored
-        }
-        return shaderString ?? k_ErrorShader.Replace("Hidden/GraphErrorShader2", shaderName);
-    }
-    internal static string GetShaderText(string path, out List<PropertyCollector.TextureInfo> configuredTextures)
-    {
-        return GetShaderText(path, out configuredTextures, null);
-    }
-}
-
-class ShaderGraphAssetPostProcessor : AssetPostprocessor
-{
-    static void RegisterShaders(string[] paths)
-    {
-        foreach (var path in paths)
-        {
-            if (!path.EndsWith(ShaderGraphImporter.ShaderGraphExtension, StringComparison.InvariantCultureIgnoreCase))
-                continue;
-
-            var mainObj = AssetDatabase.LoadMainAssetAtPath(path);
-            if (mainObj is Shader)
-                ShaderUtil.RegisterShader((Shader)mainObj);
-
-            var objs = AssetDatabase.LoadAllAssetRepresentationsAtPath(path);
-            foreach (var obj in objs)
-            {
-                if (obj is Shader)
-                    ShaderUtil.RegisterShader((Shader)obj);
-            }
+            return shaderString ?? k_ErrorShader.Replace("Hidden/GraphErrorShader2", shaderName);
-    }
-    static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
-    {
-        MaterialGraphEditWindow[] windows = Resources.FindObjectsOfTypeAll<MaterialGraphEditWindow>();
-        foreach (var matGraphEditWindow in windows)
+        internal static string GetShaderText(string path, out List<PropertyCollector.TextureInfo> configuredTextures)
-            matGraphEditWindow.forceRedrawPreviews = true;
+            return GetShaderText(path, out configuredTextures, null);
-        RegisterShaders(importedAssets);
     }
 }

com.unity.shadergraph/Editor/Importers/ShaderGraphImporterEditor.cs

 using UnityEditor.ShaderGraph.Drawing;
 using UnityEngine;
 
-[CustomEditor(typeof(ShaderGraphImporter))]
-public class ShaderGraphImporterEditor : ScriptedImporterEditor
+namespace UnityEditor.ShaderGraph
-    public override void OnInspectorGUI()
+
+    [CustomEditor(typeof(ShaderGraphImporter))]
+    public class ShaderGraphImporterEditor : ScriptedImporterEditor
-        if (GUILayout.Button("Open Shader Editor"))
+        public override void OnInspectorGUI()
-            AssetImporter importer = target as AssetImporter;
-            Debug.Assert(importer != null, "importer != null");
-            ShowGraphEditWindow(importer.assetPath);
+            if (GUILayout.Button("Open Shader Editor"))
+            {
+                AssetImporter importer = target as AssetImporter;
+                Debug.Assert(importer != null, "importer != null");
+                ShowGraphEditWindow(importer.assetPath);
+            }
-    }
+
+        internal static bool ShowGraphEditWindow(string path)
+        {
+            var guid = AssetDatabase.AssetPathToGUID(path);
+            var extension = Path.GetExtension(path);
+            if (extension != ".ShaderGraph" && extension != ".LayeredShaderGraph" && extension != ".ShaderSubGraph" && extension != ".ShaderRemapGraph")
+                return false;
-    internal static bool ShowGraphEditWindow(string path)
-    {
-        var guid = AssetDatabase.AssetPathToGUID(path);
-        var extension = Path.GetExtension(path);
-        if (extension != ".ShaderGraph" && extension != ".LayeredShaderGraph" && extension != ".ShaderSubGraph" && extension != ".ShaderRemapGraph")
-            return false;
+            var foundWindow = false;
+            foreach (var w in Resources.FindObjectsOfTypeAll<MaterialGraphEditWindow>())
+            {
+                if (w.selectedGuid == guid)
+                {
+                    foundWindow = true;
+                    w.Focus();
+                }
+            }
-        var foundWindow = false;
-        foreach (var w in Resources.FindObjectsOfTypeAll<MaterialGraphEditWindow>())
-        {
-            if (w.selectedGuid == guid)
+            if (!foundWindow)
-                foundWindow = true;
-                w.Focus();
+                var window = CreateInstance<MaterialGraphEditWindow>();
+                window.Show();
+                window.Initialize(guid);
+
+            return true;
-        if (!foundWindow)
+        [OnOpenAsset(0)]
+        public static bool OnOpenAsset(int instanceID, int line)
-            var window = CreateInstance<MaterialGraphEditWindow>();
-            window.Show();
-            window.Initialize(guid);
+            var path = AssetDatabase.GetAssetPath(instanceID);
+            return ShowGraphEditWindow(path);
-        return true;
-    }
-
-    [OnOpenAsset(0)]
-    public static bool OnOpenAsset(int instanceID, int line)
-    {
-        var path = AssetDatabase.GetAssetPath(instanceID);
-        return ShowGraphEditWindow(path);
     }
 }

com.unity.shadergraph/Editor/Importers/ShaderSubGraphImporterEditor.cs

 using UnityEngine;
 using Debug = System.Diagnostics.Debug;
 
-[CustomEditor(typeof(ShaderSubGraphImporter))]
-public class ShaderSubGraphImporterEditor : ScriptedImporterEditor
+namespace UnityEditor.ShaderGraph
-    public override void OnInspectorGUI()
+    [CustomEditor(typeof(ShaderSubGraphImporter))]
+    public class ShaderSubGraphImporterEditor : ScriptedImporterEditor
-        if (GUILayout.Button("Open Shader Editor"))
+        public override void OnInspectorGUI()
-            AssetImporter importer = target as AssetImporter;
-            Debug.Assert(importer != null, "importer != null");
-            ShaderGraphImporterEditor.ShowGraphEditWindow(importer.assetPath);
+            if (GUILayout.Button("Open Shader Editor"))
+            {
+                AssetImporter importer = target as AssetImporter;
+                Debug.Assert(importer != null, "importer != null");
+                ShaderGraphImporterEditor.ShowGraphEditWindow(importer.assetPath);
+            }
         }
     }
 }

TestProjects/HDRP_Tests/TestRunnerOptions.json

+{
+    "disableBatchMode": true,
+    "disabledOnPlatforms" : ["Darwin"]
+}