Merge branch 'master' into volumetric-lighting-updates

.gitmodules

 	url = https://github.com/Unity-Technologies/ShaderGraph
 [submodule "Tests/UTF_Core"]
 	path = Tests/UTF_Core
-url=https://github.com/Unity-Technologies/UTF_Core.git
+	url = https://github.com/Unity-Technologies/UTF_Core.git
-url=https://github.com/Unity-Technologies/UTF_Tests_HDRP.git
+	url = https://github.com/Unity-Technologies/UTF_Tests_HDRP.git

LICENSE.md

-**Unity Companion Package License v1.0 ("_License_")**
-
-Copyright © 2017 Unity Technologies ApS ("**_Unity_**")
-
-Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License ("**_Software_**"), subject to the following terms and conditions:
-
-1. *Unity Companion Use Only*. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license ("**_Engine License_**"). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
-
-1. *No Modification of Engine License*. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
-
-1. *Ownership & Grant Back to You*. 
-
-    3.1. You own your content. In this License, "derivative works" means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-    3.2. Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-    3.3. You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
-
-1. *Trademarks*. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates ("**_Trademarks_**"). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at [https://unity3d.com/public-relations/brand](https://unity3d.com/public-relations/brand).
-
-1. *Notices & Third-Party Rights*. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity "third-party notices" or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
-
-1. *DISCLAIMER, LIMITATION OF LIABILITY*. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-1. *USE IS ACCEPTANCE and License Versions*. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
-
-1. *Use in Compliance with Law and Termination*. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+Copyright © 2018 Unity Technologies ApS
-1. *Severability*. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License). 
-1. *Governing Law and Venue*. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License ("**_Dispute_**"). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.

ScriptableRenderPipeline/Core/CoreRP/CoreResources/EncodeBC6H.compute

 #include "CoreRP/ShaderLibrary/BC6H.hlsl"
 #include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 TextureCube<float4> _Source;
 RWTexture2DArray<uint4> _Target;

ScriptableRenderPipeline/Core/CoreRP/CoreResources/GPUCopy.compute

 // Autogenerated file. Do not edit by hand
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 #include "../ShaderLibrary/Common.hlsl"
 
 CBUFFER_START (UnityCBuffer)

ScriptableRenderPipeline/Core/CoreRP/CoreResources/TexturePadding.compute

 #pragma kernel KMainTop                 KERNEL_NAME=KMainTop        DIRECTION=DIRECTION_TOP
 #pragma kernel KMainRight               KERNEL_NAME=KMainRight      DIRECTION=DIRECTION_RIGHT
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 // ------------------------------------------------
 // Texture buffers

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/Drawers/ColorParameterDrawer.cs

                 return false;
 
             var o = parameter.GetObjectRef<ColorParameter>();
-            value.colorValue = EditorGUILayout.ColorField(title, value.colorValue, o.showEyeDropper, o.showAlpha, o.showAlpha);
+            value.colorValue = EditorGUILayout.ColorField(title, value.colorValue, o.showEyeDropper, o.showAlpha, o.hdr);
             return true;
         }
     }

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeComponentListEditor.cs

 {
     public sealed class VolumeComponentListEditor
     {
+        public VolumeProfile asset { get; private set; }
+
-        VolumeProfile m_Asset;
         SerializedObject m_SerializedObject;
         SerializedProperty m_ComponentsProperty;
 
             Assert.IsNotNull(asset);
             Assert.IsNotNull(serializedObject);
 
-            m_Asset = asset;
+            this.asset = asset;
             m_SerializedObject = serializedObject;
             m_ComponentsProperty = serializedObject.Find((VolumeProfile x) => x.components);
             Assert.IsNotNull(m_ComponentsProperty);
 
         void OnUndoRedoPerformed()
         {
-            m_Asset.isDirty = true;
+            asset.isDirty = true;
 
             // Dumb hack to make sure the serialized object is up to date on undo (else there'll be
             // a state mismatch when this class is used in a GameObject inspector).
             m_Editors.Clear();
 
             // Recreate editors for existing settings, if any
-            for (int i = 0; i < m_Asset.components.Count; i++)
-                CreateEditor(m_Asset.components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
+            var components = asset.components;
+            for (int i = 0; i < components.Count; i++)
+                CreateEditor(components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
         }
 
         public void Clear()
 
         public void OnGUI()
         {
-            if (m_Asset == null)
+            if (asset == null)
-            if (m_Asset.isDirty)
+            if (asset.isDirty)
-                m_Asset.isDirty = false;
+                asset.isDirty = false;
-                || AssetDatabase.IsOpenForEdit(m_Asset, StatusQueryOptions.UseCachedIfPossible);
+                || AssetDatabase.IsOpenForEdit(asset, StatusQueryOptions.UseCachedIfPossible);
 
             using (new EditorGUI.DisabledScope(!isEditable))
             {
                     {
                         var r = hscope.rect;
                         var pos = new Vector2(r.x + r.width / 2f, r.yMax + 18f);
-                        FilterWindow.Show(pos, new VolumeComponentProvider(m_Asset, this));
+                        FilterWindow.Show(pos, new VolumeComponentProvider(asset, this));
                     }
                 }
             }
             Undo.RegisterCreatedObjectUndo(component, "Add Volume Component");
 
             // Store this new effect as a subasset so we can reference it safely afterwards
-            AssetDatabase.AddObjectToAsset(component, m_Asset);
+            // Only when we're not dealing with an instantiated asset
+            if (EditorUtility.IsPersistent(asset))
+                AssetDatabase.AddObjectToAsset(component, asset);
 
             // Grow the list first, then add - that's how serialized lists work in Unity
             m_ComponentsProperty.arraySize++;
             // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
-            AssetDatabase.SaveAssets();
+            if (EditorUtility.IsPersistent(asset))
+            {
+                EditorUtility.SetDirty(asset);
+                AssetDatabase.SaveAssets();
+            }
 
             // Create & store the internal editor object for this effect
             CreateEditor(component, componentProp, forceOpen: true);
             Undo.DestroyObjectImmediate(component);
 
             // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
+            EditorUtility.SetDirty(asset);
             AssetDatabase.SaveAssets();
         }
 
             Undo.RegisterCreatedObjectUndo(newComponent, "Reset Volume Component");
 
             // Store this new effect as a subasset so we can reference it safely afterwards
-            AssetDatabase.AddObjectToAsset(newComponent, m_Asset);
+            AssetDatabase.AddObjectToAsset(newComponent, asset);
 
             // Put it in the reserved space
             property.objectReferenceValue = newComponent;
             Undo.DestroyObjectImmediate(prevComponent);
 
             // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
+            EditorUtility.SetDirty(asset);
             AssetDatabase.SaveAssets();
         }
 

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeEditor.cs

             get { return target as Volume; }
         }
 
+        VolumeProfile profileRef
+        {
+            get { return actualTarget.HasInstantiatedProfile() ? actualTarget.profile : actualTarget.sharedProfile; }
+        }
+
         void OnEnable()
         {
             var o = new PropertyFetcher<Volume>(serializedObject);
             var buttonNewRect = new Rect(fieldRect.xMax, lineRect.y, buttonWidth, lineRect.height);
             var buttonCopyRect = new Rect(buttonNewRect.xMax, lineRect.y, buttonWidth, lineRect.height);
 
-            EditorGUI.PrefixLabel(labelRect, CoreEditorUtils.GetContent("Profile|A reference to a profile asset."));
+            EditorGUI.PrefixLabel(labelRect, CoreEditorUtils.GetContent(actualTarget.HasInstantiatedProfile() ? "Profile (Instance)|A copy of a profile asset." : "Profile|A reference to a profile asset."));
-                var profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+                VolumeProfile profile = null;
+
+                if (actualTarget.HasInstantiatedProfile())
+                    profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, actualTarget.profile, typeof(VolumeProfile), false);
+                else
+                    profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+
+                    if (actualTarget.HasInstantiatedProfile()) // Clear the instantiated profile, from now on we're using shared again
+                        actualTarget.profile = null;
                 }
 
                 EditorGUI.EndProperty();
                     var scene = actualTarget.gameObject.scene;
                     var asset = VolumeProfileFactory.CreateVolumeProfile(scene, targetName);
                     m_Profile.objectReferenceValue = asset;
+                    actualTarget.profile = null; // Make sure we're not using an instantiated profile anymore
-                if (showCopy && GUI.Button(buttonCopyRect, CoreEditorUtils.GetContent("Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
+                if (showCopy && GUI.Button(buttonCopyRect, CoreEditorUtils.GetContent(actualTarget.HasInstantiatedProfile() ? "Save|Save the instantiated profile" : "Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
-                    var origin = (VolumeProfile)m_Profile.objectReferenceValue;
-                    var path = AssetDatabase.GetAssetPath(origin);
+                    var origin = profileRef;
+                    var path = AssetDatabase.GetAssetPath(m_Profile.objectReferenceValue);
                     path = AssetDatabase.GenerateUniqueAssetPath(path);
 
                     var asset = Instantiate(origin);
                     AssetDatabase.Refresh();
 
                     m_Profile.objectReferenceValue = asset;
+                    actualTarget.profile = null; // Make sure we're not using an instantiated profile anymore
                     assetHasChanged = true;
                 }
             }
-            if (m_Profile.objectReferenceValue == null)
+            if (m_Profile.objectReferenceValue == null && !actualTarget.HasInstantiatedProfile())
             {
                 if (assetHasChanged)
                     m_ComponentList.Clear(); // Asset wasn't null before, do some cleanup
-                if (assetHasChanged)
-                    RefreshEffectListEditor((VolumeProfile)m_Profile.objectReferenceValue);
+                if (assetHasChanged || profileRef != m_ComponentList.asset)
+                    RefreshEffectListEditor(profileRef);
 
                 if (!multiEdit)
                 {

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/D3D11.hlsl

 #define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
 #define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
 
-#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
-#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
-#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                                   textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                          textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                 textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)    textureName.Load(int4(unCoord2, index, 0), sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)             textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                                   textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/GLCore.hlsl

 #define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)                      SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
 #define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod)             SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
 
-#define LOAD_TEXTURE2D(textureName, unCoord2) textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod) textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex) textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index) textureName.Load(int4(unCoord2, index, 0))
-#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                                   textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                          textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                 textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)    textureName.Load(int4(unCoord2, index, 0), sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)             textureName.Load(int4(unCoord2, index, lod))
 
 #if OPENGL4_1_SM5
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                  textureName.Gather(samplerName, coord2)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/GLES2.hlsl

 #define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                                      half4(0, 0, 0, 0)
 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                             half4(0, 0, 0, 0)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                                  half4(0, 0, 0, 0)
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)                half4(0, 0, 0, 0)
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)                         half4(0, 0, 0, 0)
 
 // Gather not supported. Fallback to regular texture sampling.

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/GLES3.hlsl

 #define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                              textureName.Load(int3(unCoord2, lod))
 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                     textureName.Load(unCoord2, sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                          textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)        textureName.Load(int4(unCoord2, index, 0), sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)                 textureName.Load(int4(unCoord2, index, lod))
 
 #if GLES3_1_AEP

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/Metal.hlsl

 #define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
 #define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
 
-#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
-#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
-#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                                   textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                          textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                 textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)    textureName.Load(int4(unCoord2, index, 0), sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)             textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                                   textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/PSSL.hlsl

 #define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
 #define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
 
-#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
-#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
-#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                                   textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                          textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                 textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)    textureName.Load(int4(unCoord2, index, 0), sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)             textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                                   textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/Vulkan.hlsl

 #define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
 #define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
 
-#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
-#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
-#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                                   textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                          textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                 textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)    textureName.Load(int4(unCoord2, index, 0), sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)             textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                                   textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/XBoxOne.hlsl

 #define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2)          SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
 #define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
 
-#define LOAD_TEXTURE2D(textureName, unCoord2)                       textureName.Load(int3(unCoord2, 0))
-#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)              textureName.Load(int3(unCoord2, lod))
-#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
-#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
-#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
-#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
-#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
+#define LOAD_TEXTURE2D(textureName, unCoord2)                                   textureName.Load(int3(unCoord2, 0))
+#define LOAD_TEXTURE2D_LOD(textureName, unCoord2, lod)                          textureName.Load(int3(unCoord2, lod))
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)                 textureName.Load(unCoord2, sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))
+#define LOAD_TEXTURE2D_ARRAY_MSAA(textureName, unCoord2, index, sampleIndex)    textureName.Load(int4(unCoord2, index, 0), sampleIndex)
+#define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod)             textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                                   textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/BSDF.hlsl

 
 // Conversion FO/IOR
 
+TEMPLATE_2_REAL(IorToFresnel0, transmittedIor, incidentIor, return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor)) )
-real IorToFresnel0(real transmittedIor, real incidentIor = 1.0)
+real IorToFresnel0(real transmittedIor)
-    return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
+    return IorToFresnel0(transmittedIor, 1.0);
-// Note: Don't handle the case fresnel0 == 1
-real Fresnel0ToIor(real fresnel0)
-{
-    real sqrtF0 = sqrt(fresnel0);
-    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
-}
+// Note: We don't handle the case fresnel0 == 1
+//real Fresnel0ToIor(real fresnel0)
+//{
+//    real sqrtF0 = sqrt(fresnel0);
+//    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
+//}
+TEMPLATE_1_REAL(Fresnel0ToIor, fresnel0, return ((1.0 + sqrt(fresnel0)) / (1.0 - sqrt(fresnel0))) )
 
 // This function is a coarse approximation of computing fresnel0 for a different top than air (here clear coat of IOR 1.5) when we only have fresnel0 with air interface
 // This function is equivalent to IorToFresnel0(Fresnel0ToIor(fresnel0), 1.5)
 {
     real3 nf0 = Sq(n + 1.0) * f0 - Sq(f0 - 1.0);
     return nf0 / (1.0 - f0);
+}
+
+// same as regular refract except there is not the test for total internal reflection + the vector is flipped for processing
+real3 CoatRefract(real3 X, real3 N, real ieta)
+{
+    real XdotN = saturate(dot(N, X));
+    return ieta * X + (sqrt(1 + ieta * ieta * (XdotN * XdotN - 1)) - ieta * XdotN) * N;
 }
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 #include "API/Metal.hlsl"
 #elif defined(SHADER_API_VULKAN)
 #include "API/Vulkan.hlsl"
+#elif defined(SHADER_API_SWITCH)
+#include "API/Switch.hlsl"
 #elif defined(SHADER_API_GLCORE)
 #include "API/GLCore.hlsl"
 #elif defined(SHADER_API_GLES3)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/CommonMaterial.hlsl

     roughnessB = roughness * (1 - anisotropy);
 }
 
+void ConvertRoughnessToAnisotropy(real roughnessT, real roughnessB, out real anisotropy)
+{
+    anisotropy = ((roughnessT - roughnessB) / (roughnessT + roughnessB + 0.0001));
+}
+
 // Same as ConvertAnisotropyToRoughness but
 // roughnessT and roughnessB are clamped, and are meant to be used with punctual and directional lights.
 void ConvertAnisotropyToClampRoughness(real perceptualRoughness, real anisotropy, out real roughnessT, out real roughnessB)
     return sqrt(2.0 / (variance + 2.0));
 }
 
-// same as regular refract except there is not the test for total internal reflection + the vector is flipped for processing
-real3 CoatRefract(real3 X, real3 N, real ieta)
+// ----------------------------------------------------------------------------
+// Helper for Disney parametrization
+// ----------------------------------------------------------------------------
+
+float3 ComputeDiffuseColor(float3 baseColor, float metallic)
+{
+    return baseColor * (1.0 - metallic);
+}
+
+float3 ComputeFresnel0(float3 baseColor, float metallic, float dielectricF0)
-    real XdotN = saturate(dot(N, X));
-    return ieta * X + (sqrt(1 + ieta * ieta * (XdotN * XdotN - 1)) - ieta * XdotN) * N;
+    return lerp(dielectricF0.xxx, baseColor, metallic);
-// Parallax mapping
+// Helper for normal blending
 // ----------------------------------------------------------------------------
 
 // ref https://www.gamedev.net/topic/678043-how-to-blend-world-space-normals/#entry5287707
     return normalize(real3(n1.xy * n2.z + n2.xy * n1.z, n1.z * n2.z));
 }
 
+// ----------------------------------------------------------------------------
+// Helper for triplanar
+// ----------------------------------------------------------------------------
+
 // Ref: http://http.developer.nvidia.com/GPUGems3/gpugems3_ch01.html / http://www.slideshare.net/icastano/cascades-demo-secrets
 real3 ComputeTriplanarWeights(real3 normal)
 {
     uvZY = float2(position.z, position.y);
 }
 
+// ----------------------------------------------------------------------------
+// Helper for detail map operation
+// ----------------------------------------------------------------------------
+
 real LerpWhiteTo(real b, real t)
 {
     real oneMinusT = 1.0 - t;
     real oneMinusT = 1.0 - t;
     return real3(oneMinusT, oneMinusT, oneMinusT) + b * t;
 }
-
 
 #endif // UNITY_COMMON_MATERIAL_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/Shadow/DebugDisplayShadowMap.shader

 {
     HLSLINCLUDE
         #pragma target 4.5
-        #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+        #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
         #include "CoreRP/ShaderLibrary/Common.hlsl"
 

ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowBlurMoments.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/Shadow/ShadowMoments.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 #if MAX_MSAA > 1
 Texture2DMS<float> depthTex;

ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowClear.shader

 {
     HLSLINCLUDE
         #pragma target 4.5
-        #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+        #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
         #include "CoreRP/ShaderLibrary/Common.hlsl"
     ENDHLSL

ScriptableRenderPipeline/Core/CoreRP/Textures/BufferedRTHandleSystem.cs

 
 namespace UnityEngine.Experimental.Rendering
 {
+    /// <summary>
+    /// Implement a multiple buffering for RenderTextures.
+    /// </summary>
+    /// <exemple>
+    /// <code>
+    /// enum BufferType
+    /// {
+    ///     Color,
+    ///     Depth    
+    /// }
+    /// 
+    /// void Render()
+    /// {
+    ///     var camera = GetCamera();
+    ///     var buffers = GetFrameHistoryBuffersFor(camera);
+    ///     
+    ///     // Set reference size in case the rendering size changed this frame
+    ///     buffers.SetReferenceSize(
+    ///         GetCameraWidth(camera), GetCameraHeight(camera), 
+    ///         GetCameraUseMSAA(camera), GetCameraMSAASamples(camera)
+    ///     );
+    ///     buffers.Swap();
+    /// 
+    ///     var currentColor = buffer.GetFrameRT((int)BufferType.Color, 0);
+    ///     if (currentColor == null) // Buffer was not allocated
+    ///     {
+    ///         buffer.AllocBuffer(
+    ///             (int)BufferType.Color,      // Color buffer id
+    ///             ColorBufferAllocator,       // Custom functor to implement allocation
+    ///             2                           // Use 2 RT for this buffer for double buffering
+    ///         );
+    ///         currentColor = buffer.GetFrameRT((int)BufferType.Color, 0);
+    ///     }
+    /// 
+    ///     var previousColor = buffers.GetFrameRT((int)BufferType.Color, 1);
+    /// 
+    ///     // Use previousColor and write into currentColor
+    /// }
+    /// </code>
+    /// </exemple>
     public class BufferedRTHandleSystem : IDisposable
     {
         Dictionary<int, RTHandleSystem.RTHandle[]> m_RTHandles = new Dictionary<int, RTHandleSystem.RTHandle[]>();
 
-        public RTHandleSystem.RTHandle GetFrameRT(int id, int index)
+        /// <summary>
+        /// Return the frame RT or null.
+        /// </summary>
+        /// <param name="bufferId">Defines the buffer to use.</param>
+        /// <param name="frameIndex"></param>
+        /// <returns>The frame RT or null when the <paramref name="bufferId"/> was not previously allocated (<see cref="BufferedRTHandleSystem.AllocBuffer(int, Func{RTHandleSystem, int, RTHandleSystem.RTHandle}, int)" />).</returns>
+        public RTHandleSystem.RTHandle GetFrameRT(int bufferId, int frameIndex)
-            if (!m_RTHandles.ContainsKey(id))
+            if (!m_RTHandles.ContainsKey(bufferId))
-            Assert.IsTrue(index >= 0 && index < m_RTHandles[id].Length);
+            Assert.IsTrue(frameIndex >= 0 && frameIndex < m_RTHandles[bufferId].Length);
-            return m_RTHandles[id][index];
+            return m_RTHandles[bufferId][frameIndex];
+        /// <summary>
+        /// Allocate RT handles for a buffer.
+        /// </summary>
+        /// <param name="bufferId">The buffer to allocate.</param>
+        /// <param name="allocator">The functor to use for allocation.</param>
+        /// <param name="bufferCount">The number of RT handles for this buffer.</param>
-            int id, 
+            int bufferId, 
-            int bufferSize
+            int bufferCount
-            var buffer = new RTHandleSystem.RTHandle[bufferSize];
-            m_RTHandles.Add(id, buffer);
+            var buffer = new RTHandleSystem.RTHandle[bufferCount];
+            m_RTHandles.Add(bufferId, buffer);
 
             // First is autoresized
             buffer[0] = allocator(m_RTHandleSystem, 0);
             }
         }
 
+        /// <summary>
+        /// Set the reference size for this RT Handle System (<see cref="RTHandleSystem.SetReferenceSize(int, int, bool, MSAASamples)"/>)
+        /// </summary>
+        /// <param name="width">The width of the RTs of this buffer.</param>
+        /// <param name="height">The height of the RTs of this buffer.</param>
+        /// <param name="msaa">Whether this buffer use MSAA.</param>
+        /// <param name="msaaSamples">Number of MSAA samples for this buffer.</param>
+        /// <summary>
+        /// Swap the buffers.
+        /// 
+        /// Take care that if the new current frame needs resizing, it will occurs during the this call.
+        /// </summary>
         public void Swap()
         {
             foreach (var item in m_RTHandles)
             Dispose(true);
         }
 
+        /// <summary>
+        /// Deallocate and clear all buffers.
+        /// </summary>
         public void ReleaseAll()
         {
             foreach (var item in m_RTHandles)

ScriptableRenderPipeline/Core/CoreRP/Utilities/CoreUtils.cs

             };
             return mat;
         }
+        public static bool HasFlag<T>(T mask, T flag) where T : IConvertible
+        {
+            return (mask.ToUInt32(null) & flag.ToUInt32(null)) != 0;
+        }
 
         public static void SetKeyword(CommandBuffer cmd, string keyword, bool state)
         {

ScriptableRenderPipeline/Core/CoreRP/Volume/Volume.cs

             }
         }
 
+        public bool HasInstantiatedProfile()
+        {
+            return m_InternalProfile != null;
+        }
+
         // Needed for state tracking (see the comments in Update)
         int m_PreviousLayer;
         float m_PreviousPriority;

ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeManager.cs

     public sealed class VolumeManager
     {
         //>>> System.Lazy<T> is broken in Unity (legacy runtime) so we'll have to do it ourselves :|
-        static volatile VolumeManager s_Instance;
-        static object s_LockObj = new UnityObject();
+        static readonly VolumeManager s_Instance = new VolumeManager();
+        public static VolumeManager instance { get { return s_Instance; } }
-        public static VolumeManager instance
-        {
-            get
-            {
-                // Double-lock checking
-                if (s_Instance == null)
-                {
-                    lock (s_LockObj) // Lock on a separate object to avoid deadlocks
-                    {
-                        if (s_Instance == null)
-                            s_Instance = new VolumeManager();
-                    }
-                }
-
-                return s_Instance;
-            }
-        }
+        // Explicit static constructor to tell the C# compiler not to mark type as beforefieldinit
+        static VolumeManager() { }
         //<<<
 
         // Internal stack

ScriptableRenderPipeline/Core/LICENSE.md

-**Unity Companion Package License v1.0 ("_License_")**
-
-Copyright © 2017 Unity Technologies ApS ("**_Unity_**")
-
-Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License ("**_Software_**"), subject to the following terms and conditions:
-
-1. *Unity Companion Use Only*. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license ("**_Engine License_**"). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
-
-1. *No Modification of Engine License*. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
-
-1. *Ownership & Grant Back to You*. 
-
-    3.1. You own your content. In this License, "derivative works" means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-    3.2. Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-    3.3. You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
-
-1. *Trademarks*. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates ("**_Trademarks_**"). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at [https://unity3d.com/public-relations/brand](https://unity3d.com/public-relations/brand).
-
-1. *Notices & Third-Party Rights*. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity "third-party notices" or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
-
-1. *DISCLAIMER, LIMITATION OF LIABILITY*. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-1. *USE IS ACCEPTANCE and License Versions*. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
-
-1. *Use in Compliance with Law and Termination*. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+Render Pipeline Core copyright © 2018 Unity Technologies ApS
-1. *Severability*. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License). 
-1. *Governing Law and Venue*. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License ("**_Dispute_**"). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.

ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md

 - Disable per-object culling that was executed in C++ in HD whereas it was not used (Optimization)
 - Enable texture streaming debugging (was not working before 2018.2)
 
+### Changed, Removals and deprecations
+- Removed GlobalLightLoopSettings.maxPlanarReflectionProbes and instead use value of GlobalLightLoopSettings.planarReflectionProbeCacheSize
+
+- Trigger a build exception when trying to build an unsupported platform
+- Introduce the VolumetricLightingController component, which can (and should) be placed on the camera, and allows one to control the near and the far plane of the V-Buffer (volumetric "froxel" buffer) along with the depth distribution (from logarithmic to linear)
-- 
+- Remove Resource folder of PreIntegratedFGD and add the resource to RenderPipeline Asset
+- Default number of planar reflection change from 4 to 2
 
 ### Bug fixes
 - Fix ConvertPhysicalLightIntensityToLightIntensity() function used when creating light from script to match HDLightEditor behavior
 - Screen Space Refraction proxy model uses the proxy of the first environment light (Reflection probe/Planar probe) or the sky
 - Moved RTHandle static methods to RTHandles
 - Renamed RTHandle to RTHandleSystem.RTHandle
+- Move code for PreIntegratedFDG (Lit.shader) into its dedicated folder to be share with other material
+- Move code for LTCArea (Lit.shader) into its dedicated folder to be share with other material
  
 ### Bug fixes
 - Fix fog flags in scene view is now taken into account
 - Fix the near plane of the V-Buffer causing out-of-bounds look-ups in the clustered data structure.
 - Depth and color pyramid are properly computed and sampled when the camera renders inside a viewport of a RTHandle.
+- Fix decal atlas debug view to work correctly when shadow atlas view is also enabled
 
 ## [2018.1.0b13]
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

             m_ActualHeight = camera.pixelHeight;
             var screenWidth = m_ActualWidth;
             var screenHeight = m_ActualHeight;
+#if !UNITY_SWITCH
             if (frameSettings.enableStereo)
             {
                 screenWidth = XRSettings.eyeTextureWidth;
 
                 ConfigureStereoMatrices();
             }
+#endif
 
             // Unfortunately sometime (like in the HDCameraEditor) HDUtils.hdrpSettings can be null because of scripts that change the current pipeline...
             m_msaaSamples = HDUtils.hdrpSettings != null ? HDUtils.hdrpSettings.msaaSampleCount : MSAASamples.None;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugColorPicker.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplayLatlong.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewMaterialGBuffer.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

             { 
                 using (new ProfilingSample(cmd, "Display Decal Atlas", CustomSamplerId.DisplayDebugDecalsAtlas.GetSampler()))
                 {
-                    HDUtils.BlitQuad(cmd, Atlas.AtlasTexture, new Vector4(1,1,0,0), new Vector4(width / hdCamera.actualWidth, overlaySize / hdCamera.actualHeight, x / hdCamera.actualWidth, y / hdCamera.actualHeight), (int)debugDisplaySettings.decalsDebugSettings.m_MipLevel, true);
+                    cmd.SetViewport(new Rect(x, y, overlaySize, overlaySize));
+                    HDUtils.BlitQuad(cmd, Atlas.AtlasTexture, new Vector4(1, 1, 0 ,0), new Vector4(1, 1, 0, 0), (int)debugDisplaySettings.decalsDebugSettings.m_MipLevel, true);
                     HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, hdCamera.actualWidth);
                 }
             }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

                 newAsset.opaqueAtmosphericScattering = Load<Shader>(HDRenderPipelinePath + "Sky/OpaqueAtmosphericScattering.shader");
                 newAsset.hdriSky = Load<Shader>(HDRenderPipelinePath + "Sky/HDRISky/HDRISky.shader");
                 newAsset.proceduralSky = Load<Shader>(HDRenderPipelinePath + "Sky/ProceduralSky/ProceduralSky.shader");
+                // Skybox/Cubemap is a builtin shader, must use Sahder.Find to access it. It is fine because we are in the editor
+                newAsset.skyboxCubemap = Shader.Find("Skybox/Cubemap");
+
+                // Material
+                newAsset.preIntegratedFGD = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD.shader");
-
-                // Skybox/Cubemap is a builtin shader, must use Sahder.Find to access it. It is fine because we are in the editor
-                newAsset.skyboxCubemap = Shader.Find("Skybox/Cubemap");
 
                 // Shadow
                 newAsset.shadowClearShader = Load<Shader>(CorePath + "Shadow/ShadowClear.shader");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Handles.cs

         [DrawGizmo(GizmoType.Selected)]
         static void DrawSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
         {
+            var e = GetEditorFor(reflectionProbe);
+            if (e == null || !e.sceneViewEditing)
+                return;
+
             var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
 
             Gizmos_Influence(reflectionProbe, reflectionData, null, false);
         [DrawGizmo(GizmoType.NonSelected)]
         static void DrawNonSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
         {
+            var e = GetEditorFor(reflectionProbe);
+            if (e == null || !e.sceneViewEditing)
+                return;
+                
             var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
             if (reflectionData != null)
                 HDReflectionProbeEditorUtility.ChangeVisibility(reflectionProbe, false);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs

             EditorGUI.showMixedValue = false;
             if (EditorGUI.EndChangeCheck())
                 s.SetShapeTarget(p.influenceShape.intValue);
+
+            if (p.proxyVolumeComponent.objectReferenceValue != null)
+            {
+                var proxy = (ReflectionProxyVolumeComponent)p.proxyVolumeComponent.objectReferenceValue;
+                if ((int)proxy.proxyVolume.shapeType != p.influenceShape.enumValueIndex)
+                    EditorGUILayout.HelpBox(
+                        "Proxy volume and influence volume have different shape types, this is not supported.",
+                        MessageType.Error,
+                        true
+                    );
+            }
         }
 
         static void Drawer_IntensityMultiplier(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

                     (s, d, o) => d.influenceVolume,
                     InfluenceVolumeUI.SectionFoldoutShape
                 ),
+                CED.Action(Drawer_DifferentShapeError),
                 SectionFoldoutInfluenceSettings,
                 SectionFoldoutCaptureSettings,
                 CED.Select(
         {
             // EditorGUILayout.PropertyField(d.captureMirrorPlaneLocalPosition, _.GetContent("Plane Position"));
             // EditorGUILayout.PropertyField(d.captureMirrorPlaneLocalNormal, _.GetContent("Plane Normal"));
+        }
+
+        static void Drawer_DifferentShapeError(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
+        {
+            var proxy = d.proxyVolumeReference.objectReferenceValue as ReflectionProxyVolumeComponent;
+            if (proxy != null && (int)proxy.proxyVolume.shapeType != d.influenceVolume.shapeType.enumValueIndex)
+            {
+                EditorGUILayout.HelpBox(
+                    "Proxy volume and influence volume have different shape types, this is not supported.",
+                    MessageType.Error,
+                    true
+                );
+            }
         }
 
         static void Drawer_SectionCaptureSettings(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DrawDiffusionProfile.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DrawTransmittanceGraph.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/BaseMaterialUI.cs

             public abstract void OnFindProperty(MaterialProperty[] props);
 
             public abstract void OnGUI();
+
+            internal abstract string ToShaderPropertiesStringInternal();
         }
 
         public class GroupProperty : BaseProperty
             private readonly BaseProperty[] m_ChildProperties;
-
-            public bool Foldout = false;
+            private readonly Property m_Show;
-            public GroupProperty(BaseMaterialGUI parent, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
-                : this(parent, string.Empty, childProperties, isVisible)
+            public GroupProperty(BaseMaterialGUI parent, string groupName, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
+                : this(parent, groupName, string.Empty, childProperties, isVisible)
-            public GroupProperty(BaseMaterialGUI parent, string groupTitle, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
+            public GroupProperty(BaseMaterialGUI parent, string groupName, string groupTitle, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
+                m_Show = new Property(parent, groupName + "Show", "", false);
+
                 m_Title = groupTitle;
                 m_ChildProperties = childProperties;
             }
+                m_Show.OnFindProperty(props);
+
                 foreach (var c in m_ChildProperties)
                 {
                     c.OnFindProperty(props);
                 {
                     if (!string.IsNullOrEmpty(m_Title))
                     {
-                        Foldout = EditorGUILayout.Foldout(Foldout, m_Title);
+                        m_Show.BoolValue = EditorGUILayout.Foldout(m_Show.BoolValue, m_Title);
-                    else
+                    else if (m_Show.IsValid)
-                        Foldout = true;
+                        m_Show.BoolValue = true;
-                    if (Foldout)
+                    if (!m_Show.IsValid || m_Show.BoolValue)
                     {
                         EditorGUI.indentLevel++;
 
                     }
                 }
             }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                string outputString = string.Empty;
+
+                foreach (var c in m_ChildProperties)
+                {
+                    outputString += c.ToShaderPropertiesStringInternal() + "\n";
+                }
+
+                return outputString;
+            }
-         
+
-            protected MaterialProperty m_MaterialProperty = null;
+            public MaterialProperty m_MaterialProperty = null;
 
             protected readonly GUIContent m_GuiContent = null;
 
             {
                 get { return m_MaterialProperty != null; }
             }
-        
+
             public float FloatValue
             {
                 get { return m_MaterialProperty.floatValue; }
             public bool BoolValue
             {
-                get { return Math.Abs(m_MaterialProperty.floatValue) > 0.0f; }
+                get { return m_MaterialProperty == null || Math.Abs(m_MaterialProperty.floatValue) > 0.0f; }
                 set { m_MaterialProperty.floatValue = value ? 1.0f : 0.0f; }
             }
 
                 set { m_MaterialProperty.vectorValue = value; }
             }
 
-            public Property(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true)
-                : this(parent, propertyName, guiText, string.Empty, isMandatory)
+            public Property(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : this(parent, propertyName, guiText, string.Empty, isMandatory, isVisible)
-            public Property(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent)
+            public Property(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, isVisible)
             {
                 m_GuiContent = new GUIContent(guiText, toolTip);
                 PropertyName = propertyName;
                     Parent.m_MaterialEditor.ShaderProperty(m_MaterialProperty, m_GuiContent);
                 }
             }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                if (IsValid
+                    && (IsVisible == null || IsVisible(this)))
+                {
+                    switch (m_MaterialProperty.type)
+                    {
+                        case MaterialProperty.PropType.Color:
+                            return string.Format("{0}(\"{1}\", Color) = (1, 1, 1, 1)", PropertyName, PropertyText);
+
+                        case MaterialProperty.PropType.Vector:
+                            return string.Format("{0}(\"{1}\", Vector) = (0, 0, 0, 0)", PropertyName, PropertyText);
+
+                        case MaterialProperty.PropType.Float:
+                            return string.Format("{0}(\"{1}\", Float) = 0.0", PropertyName, PropertyText);
+
+                        case MaterialProperty.PropType.Range:
+                            return string.Format("{0}(\"{1}\", Range({2:0.0###}, {3:0.0###})) = 0", PropertyName, PropertyText, m_MaterialProperty.rangeLimits.x, m_MaterialProperty.rangeLimits.y);
+
+                        case MaterialProperty.PropType.Texture:
+                            return string.Format("{0}(\"{1}\", 2D) = \"white\" {{}}", PropertyName, PropertyText);
+
+                        default:
+                            // Unknown type... default to outputting a float.
+                            return string.Format("{0}(\"{1}\", Float) = 0.0", PropertyName, PropertyText);
+                    }
+                }
+                else
+                {
+                    // Material property is not loaded, default to outputting a float.
+                    return string.Format("{0}(\"{1}\", Float) = 0.0", PropertyName, PropertyText);
+                }
+            }
         }
 
         public class ComboProperty : Property
 
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, bool isMandatory = true)
-                : base(parent, propertyName, guiText, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, isMandatory, isVisible)
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, int[] values, bool isMandatory = true)
-                : base(parent, propertyName, guiText, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, int[] values, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, isMandatory, isVisible)
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, int[] values, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, int[] values, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
             {
                 m_Options = options;
                 m_Values = values;
 
         public class DiffusionProfileProperty : Property
         {
-            public DiffusionProfileProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public DiffusionProfileProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
             {
             }
 
 
             private MaterialProperty m_ExtraProperty;
 
-            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true)
-                : base(parent, propertyName, guiText, isMandatory)
+            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, isMandatory, isVisible)
-            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
-            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string extraPropertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string extraPropertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
             {
                 ExtraPropertyName = extraPropertyName;
             }
                     Parent.m_MaterialEditor.TexturePropertySingleLine(m_GuiContent, m_MaterialProperty, m_ExtraProperty);
                 }
             }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                return string.Format("{0}(\"{1}\", 2D) = \"white\" {{}}\n" +
+                                     "{2}(\"{3}\", Float) = 0.0",
+                                     PropertyName, PropertyText,
+                                     ExtraPropertyName, ExtraPropertyName);
+            }
         }
 
         public class TextureProperty : Property
                 A,
             }
 
+            public enum PlanarSpace
+            {
+                World,
+                Local
+            }
+
+            public enum NormalSpace
+            {
+                Tangent,
+                Object
+            }
+
             public enum UVMapping
             {
                 UV0,
                 Triplanar,
             }
 
+            public Property m_Show;
+
+            public Property m_ConstantProperty;
+
-            public Property m_LocalOrWorldProperty;
+            public ComboProperty m_LocalOrWorldProperty;
-            public ComboProperty m_TilingProperty;
+            public ComboProperty m_NormalSpaceProperty;
 
             public Property m_ChannelProperty;
 
 
-            public bool Foldout = false;
+            public string m_ConstantPropertyName;
+
+            public bool m_IsNormalMap;
-            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, bool isMandatory = true, bool isNormalMap = false)
-                : this(parent, propertyName, constantPropertyName, guiText, string.Empty, isMandatory, isNormalMap)
+            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, bool useConstantAsTint, bool isMandatory = true, bool isNormalMap = false, Func<object, bool> isVisible = null)
+                : this(parent, propertyName, constantPropertyName, guiText, string.Empty, useConstantAsTint, isMandatory, isNormalMap, isVisible)
-            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, string toolTip, bool isMandatory = true, bool isNormalMap = false)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, string toolTip, bool useConstantAsTint, bool isMandatory = true, bool isNormalMap = false, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
-                m_TextureProperty = new TextureOneLineProperty(parent, propertyName, constantPropertyName, guiText, toolTip, isMandatory);
+                m_IsNormalMap = isNormalMap;
+
+                m_ConstantPropertyName = constantPropertyName;
+
+                m_Show = new Property(parent, propertyName + "Show", "", isMandatory);
+
+                if (useConstantAsTint == false)
+                {
+                    m_ConstantProperty = new Property(parent, constantPropertyName, guiText, toolTip, isMandatory);
+                }
+
+                m_TextureProperty = new TextureOneLineProperty(parent, propertyName, useConstantAsTint ? constantPropertyName : string.Empty, guiText, toolTip, isMandatory);
-                m_LocalOrWorldProperty = new Property(parent, propertyName + "LocalOrWorld", "Local Space", "Whether Planar or Triplanar is using Local or World space.", false);
+                m_LocalOrWorldProperty = new ComboProperty(parent, propertyName + "UVLocal", "Local or world", Enum.GetNames(typeof(PlanarSpace)), false);
+
+                m_NormalSpaceProperty = new ComboProperty(parent, propertyName + "ObjSpace", "Normal space", Enum.GetNames(typeof(NormalSpace)), false);
-                m_TilingProperty = new ComboProperty(parent, propertyName + "Tiling", "Tiling", Enum.GetNames(typeof(Tiling)), false);
-                m_ChannelProperty = new Property(parent, propertyName + "Channel", "Channel", false);
+                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);
             {
                 base.OnFindProperty(props);
 
+                m_Show.OnFindProperty(props);
+                if (m_ConstantProperty != null)
+                {
+                    m_ConstantProperty.OnFindProperty(props);
+                }
-                m_TilingProperty.OnFindProperty(props);
+                m_NormalSpaceProperty.OnFindProperty(props);
                 m_ChannelProperty.OnFindProperty(props);
                 m_RemapProperty.OnFindProperty(props);
                 m_InvertRemapProperty.OnFindProperty(props);
             {
-                if (m_TextureProperty.IsValid
-                    && (IsVisible == null || IsVisible(this)))
+                if ((IsVisible == null || IsVisible(this))
+                    && m_Show.IsValid
+                    && m_TextureProperty.IsValid)
-                    Foldout = EditorGUILayout.Foldout(Foldout, PropertyText);
-                    if (Foldout)
+                    m_Show.BoolValue = EditorGUILayout.Foldout(m_Show.BoolValue, PropertyText);
+
+                    if (m_Show.BoolValue)
+                        if (m_ConstantProperty != null && m_ConstantProperty.IsValid
+                            && m_TextureProperty.TextureValue == null)
+                        {
+                            m_ConstantProperty.OnGUI();
+                        }
 
                         m_TextureProperty.OnGUI();
 
-                            m_LocalOrWorldProperty.OnGUI();
-                            m_TilingProperty.OnGUI();
-                            m_LocalOrWorldProperty.OnGUI();
+
+                            Parent.m_MaterialEditor.TextureScaleOffsetProperty(m_TextureProperty.m_MaterialProperty);
+
+                            if (m_UvSetProperty.FloatValue >= (float)UVMapping.PlanarXY)
+                            {
+                                m_LocalOrWorldProperty.OnGUI();
+                            }
+
+                            if (m_IsNormalMap)
+                            {
+                                m_NormalSpaceProperty.OnGUI();
+                            }
 
                             if (m_RemapProperty.IsValid)
                             {
-                                EditorGUILayout.MinMaxSlider(m_RemapProperty.PropertyText, ref remap.x, ref remap.y,
-                                    0.0f, 1.0f);
+                                EditorGUILayout.MinMaxSlider(m_RemapProperty.PropertyText, ref remap.x, ref remap.y, 0.0f, 1.0f);
-                                m_InvertRemapProperty.OnGUI();
+                                if (m_InvertRemapProperty.IsValid)
+                                {
+                                    m_InvertRemapProperty.OnGUI();
+                                }
                             }
                         }
 
             }
-        }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                string constantName = m_ConstantPropertyName.StartsWith("_")
+                    ? m_ConstantPropertyName.Substring(1)
+                    : m_ConstantPropertyName;
+
+                return string.Format(
+                    "[HideInInspector] {0}MapShow(\"{1} Show\", Float) = 0\n" +
+                    "{0}(\"{1}\", Range(0.0, 1.0)) = 0\n" +
+                    "{2}(\"{1} Map\", 2D) = " + (m_IsNormalMap ? "\"bump\"" : "\"white\"") + " {{ }}\n" +
+                    "{0}UseMap(\"{1} Use Map\", Float) = 0\n" +
+                    (m_IsNormalMap ? "{0}ObjSpace(\"{1} Object Space\", Float) = 0\n" : "") +
+                    "{2}UV(\"{1} Map UV\", Float) = 0.0\n" +
+                    "{2}UVLocal(\"{1} Map UV Local\", Float) = 0.0\n" +
+                    "{2}Channel(\"{1} Map Channel\", Float) = 0.0\n" +
+                    "{2}ChannelMask(\"{1} Map Channel Mask\", Vector) = (1, 0, 0, 0)\n" +
+                    "{0}Remap(\"{1} Remap\", Vector) = (0, 1, 0, 0)\n" +
+                    "[ToggleUI] {0}RemapInverted(\"Invert {1} Remap\", Float) = 0.0\n" +
+                    "[HideInInspector] {0}Range(\"{1} Range\", Vector) = (0, 1, 0, 0)\n",
+                    m_ConstantPropertyName, constantName, PropertyName);
+            }
+    }
         #endregion
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs

 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+        protected static class StylesStackLit
+        {
+            public static GUIContent useLocalPlanarMapping = new GUIContent("Use Local Planar Mapping", "Use local space for planar/triplanar mapping instead of world space");
+        };
+
         #region Strings
 
         protected const string k_DoubleSidedNormalMode = "_DoubleSidedNormalMode";
         // Base
         protected const string k_BaseColor = "_BaseColor";
         protected const string k_BaseColorMap = "_BaseColorMap";
+        protected const string k_BaseColorMapUV = "_BaseColorMapUV";
-        protected const string k_MetallicRemapMin = "_MetallicRemap";
+        protected const string k_MetallicMapUV = "_MetallicMapUV";
-        protected const string k_Smoothness1 = "_SmoothnessA";
-        protected const string k_Smoothness1Map = "_SmoothnessAMap";
-        protected const string k_Smoothness1RemapMin = "_SmoothnessARemap";
+        protected const string k_DielectricIor = "_DielectricIor";
+
+        protected const string k_SmoothnessA = "_SmoothnessA";
+        protected const string k_SmoothnessAMap = "_SmoothnessAMap";
+        protected const string k_SmoothnessAMapUV = "_SmoothnessAMapUV";
+        protected const string k_NormalMapUV = "_NormalMapUV";
+        protected const string k_AmbientOcclusion = "_AmbientOcclusion";
+        protected const string k_AmbientOcclusionMap = "_AmbientOcclusionMap";
+        protected const string k_AmbientOcclusionMapUV = "_AmbientOcclusionMapUV";
+
+        protected const string k_EmissiveColorMapUV = "_EmissiveColorMapUV";
+        // Coat
+        protected const string k_EnableCoat = "_EnableCoat";
+        protected const string k_CoatSmoothness = "_CoatSmoothness";
+        protected const string k_CoatSmoothnessMap = "_CoatSmoothnessMap";
+        protected const string k_CoatSmoothnessMapUV = "_CoatSmoothnessMapUV";
+        protected const string k_CoatIor = "_CoatIor";
+        protected const string k_CoatThickness = "_CoatThickness";
+        protected const string k_CoatExtinction = "_CoatExtinction";
+
-        protected const string k_DiffusionProfileName = "_DiffusionProfile";
-        protected const string k_SubsurfaceMaskName = "_SubsurfaceMask";
+        protected const string k_EnableSubsurfaceScattering = "_EnableSubsurfaceScattering";
+        protected const string k_DiffusionProfile = "_DiffusionProfile";
+        protected const string k_SubsurfaceMask = "_SubsurfaceMask";
+        protected const string k_SubsurfaceMaskMapUV = "_SubsurfaceMaskMapUV";
-        protected const string k_ThicknessName = "_Thickness";
-        protected const string k_ThicknessMapName = "_ThicknessMap";
-        protected const string k_ThicknessRemapName = "_ThicknessRemap";
+        // Translucency
+        protected const string k_EnableTransmission = "_EnableTransmission";
+        protected const string k_Thickness = "_Thickness";
+        protected const string k_ThicknessMap = "_ThicknessMap";
+        protected const string k_ThicknessMapUV = "_ThicknessMapUV";
-        protected const string k_Smoothness2 = "_SmoothnessB";
-        protected const string k_Smoothness2Map = "_SmoothnessBMap";
-        protected const string k_SmoothnessRemap2Min = "_SmoothnessBRemap";
+        protected const string k_EnableDualSpecularLobe = "_EnableDualSpecularLobe";
+        protected const string k_SmoothnessB = "_SmoothnessB";
+        protected const string k_SmoothnessBMap = "_SmoothnessBMap";
+        protected const string k_SmoothnessBMapUV = "_SmoothnessBMapUV";
-        //// transparency params
-        //protected MaterialProperty transmissionEnable = null;
-        //protected const string kTransmissionEnable = "_TransmissionEnable";
+        // Anisotropy
+        protected const string k_EnableAnisotropy = "_EnableAnisotropy";
+        protected const string k_Anisotropy = "_Anisotropy";
+        protected const string k_AnisotropyMap = "_AnisotropyMap";
+        protected const string k_AnisotropyMapUV = "_AnisotropyMapUV";
-        //protected MaterialProperty ior = null;
-        //protected const string kIor = "_Ior";
-        //protected MaterialProperty transmittanceColor = null;
-        //protected const string kTransmittanceColor = "_TransmittanceColor";
-        //protected MaterialProperty transmittanceColorMap = null;
-        //protected const string kTransmittanceColorMap = "_TransmittanceColorMap";
-        //protected MaterialProperty atDistance = null;
-        //protected const string kATDistance = "_ATDistance";
-        //protected MaterialProperty thicknessMultiplier = null;
-        //protected const string kThicknessMultiplier = "_ThicknessMultiplier";
-        //protected MaterialProperty refractionModel = null;
-        //protected const string kRefractionModel = "_RefractionModel";
-        //protected MaterialProperty refractionSSRayModel = null;
-        //protected const string kRefractionSSRayModel = "_RefractionSSRayModel";
+        // Iridescence
+        protected const string k_EnableIridescence = "_EnableIridescence";
+        protected const string k_IridescenceIor = "_IridescenceIor";
+        protected const string k_IridescenceThickness = "_IridescenceThickness";
+        protected const string k_IridescenceThicknessMap = "_IridescenceThicknessMap";
+        protected const string k_IridescenceThicknessMapUV = "_IridescenceThicknessMapUV";
+
+        // Stencil is use to control lighting mode (regular, split lighting)
+        protected const string kStencilRef = "_StencilRef";
+        protected const string kStencilWriteMask = "_StencilWriteMask";
+        protected const string kStencilRefMV = "_StencilRefMV";
+        protected const string kStencilWriteMaskMV = "_StencilWriteMaskMV";
+
         #endregion
 
         // Add the properties into an array.
+        private Property EnableSSS;
+        private Property EnableTransmission;
+        private Property EnableCoat;
+        private Property EnableAnisotropy;
+        private Property EnableDualSpecularLobe;
+        private Property EnableIridescence;
+
-            _baseMaterialProperties = new GroupProperty(this, new BaseProperty[]
+            _baseMaterialProperties = new GroupProperty(this, "_BaseMaterial", new BaseProperty[]
-                new Property(this, k_DoubleSidedNormalMode, "Normal mode", "This will modify the normal base on the selected mode. Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal.", false), 
+                new Property(this, k_DoubleSidedNormalMode, "Normal mode", "This will modify the normal base on the selected mode. Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal.", false),
-            _materialProperties = new GroupProperty(this, new BaseProperty[]
+            //
+            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);
+            EnableAnisotropy = new Property(this, k_EnableAnisotropy, "Enable Anisotropy", "Enable anisotropy, correct anisotropy for punctual light but very coarse approximated for reflection", true);
+            EnableDualSpecularLobe = new Property(this, k_EnableDualSpecularLobe, "Enable Dual Specular Lobe", "Enable a second specular lobe, aim to simulate a mix of a narrow and a haze lobe that better match measured material", true);
+            EnableIridescence = new Property(this, k_EnableIridescence, "Enable Iridescence", "Enable physically based iridescence layer", true);
+
+            // All material properties
+            _materialProperties = new GroupProperty(this, "_Material", new BaseProperty[]
-                new GroupProperty(this, "Standard", new BaseProperty[]
+                new GroupProperty(this, "_MaterialFeatures", "Material Features", new BaseProperty[]
-                    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Base Color + Opacity", "Albedo (RGB) and Opacity (A)", false),
-                    new TextureProperty(this, k_MetallicMap, k_Metallic, "Metallic", "Metallic", false), 
-                    new TextureProperty(this, k_Smoothness1Map, k_Smoothness1, "Smoothness", "Smoothness", false),
-                    // TODO: Special case for normal maps.
-                    new TextureProperty(this, k_NormalMap, k_NormalScale, "Normal TODO", "Normal Map", false, true),
-
-                    //new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Dielectric IoR", "Index of Refraction for Dielectric", false),
+                    EnableDualSpecularLobe,
+                    EnableAnisotropy,
+                    EnableCoat,
+                    EnableIridescence,
+                    EnableSSS,
+                    EnableTransmission
-                new GroupProperty(this, "Emissive", new BaseProperty[]
+                new GroupProperty(this, "_Standard", "Standard", new BaseProperty[]
-                    new TextureProperty(this, k_EmissiveColorMap, k_EmissiveColor, "Emissive Color", "Emissive", false),
-                    new Property(this, k_EmissiveIntensity, "Emissive Intensity", "Emissive", false),
-                    new Property(this, k_AlbedoAffectEmissive, "Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.", false),
+                    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Base Color + Opacity", "Albedo (RGB) and Opacity (A)", true, false),
+                    new TextureProperty(this, k_MetallicMap, k_Metallic, "Metallic", "Metallic", false, false),
+                    new Property(this, k_DielectricIor, "DieletricIor", "IOR use for dielectric material (i.e non metallic material)", false),
+                    new TextureProperty(this, k_SmoothnessAMap, k_SmoothnessA, "Smoothness", "Smoothness", false, false),
+                    new TextureProperty(this, k_NormalMap, k_NormalScale, "Normal", "Normal Map", false, false, true),
+                    new TextureProperty(this, k_AmbientOcclusionMap, k_AmbientOcclusion, "AmbientOcclusion", "AmbientOcclusion Map", false, false),
-                //new GroupProperty(this, "Coat", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "SmoothnessCoat", "smoothnessCoat", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Index Of Refraction", "iorCoat", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Normal", "normal Coat", false),
-                //}),
+                new GroupProperty(this, "_DualSpecularLobe", "Dual Specular Lobe", new BaseProperty[]
+                {
+                    new TextureProperty(this, k_SmoothnessBMap, k_SmoothnessB, "Smoothness B", "Smoothness B", false, false),
+                    new Property(this, k_LobeMix, "Lobe Mix", "Lobe Mix", false),
+                }, _ => EnableDualSpecularLobe.BoolValue == true),
-                new GroupProperty(this, "Sub-Surface Scattering", new BaseProperty[]
+                new GroupProperty(this, "_Anisotropy", "Anisotropy", new BaseProperty[]
-                    new DiffusionProfileProperty(this, k_DiffusionProfileName, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false),
-                    new TextureProperty(this, k_SubsurfaceMaskName, "Subsurface mask map (R)", "Determines the strength of the subsurface scattering effect.", false),
-                }/*, _ => _materialId == MaterialId.SubSurfaceScattering*/),
+                    new Property(this, k_Anisotropy, "Anisotropy", "Anisotropy of base layer", false),
+                    // TODO: Tangent map and rotation
+                }, _ => EnableAnisotropy.BoolValue == true),
-                new GroupProperty(this, "Second Specular Lobe", new BaseProperty[]
+                new GroupProperty(this, "_Coat", "Coat", new BaseProperty[]
-                    new TextureProperty(this, k_Smoothness2Map, k_Smoothness2, "Smoothness2", "Smoothness2", false),
-                    new Property(this, k_LobeMix, "Lobe Mix", "Lobe Mix", false), 
-                }),
+                    new TextureProperty(this, k_CoatSmoothnessMap, k_CoatSmoothness, "Coat smoothness", "Coat smoothness", false),
+                    new Property(this, "_CoatIor", "Coat IOR", "Index of refraction", false),
+                    new Property(this, "_CoatThickness", "Coat Thickness", "Coat thickness", false),
+                    new Property(this, "_CoatExtinction", "Coat Absorption", "Coat absorption tint (the thicker the coat, the more that color is removed)", false),
+                }, _ =>EnableCoat.BoolValue == true),
-                //new GroupProperty(this, "Anisotropy", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Anisotropy Strength", "anisotropy strength", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Rotation", "rotation", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Tangent", "tangent", false),
-                //}),
+                new GroupProperty(this, "_Iridescence", "Iridescence", new BaseProperty[]
+                {
+                    new Property(this, "_IridescenceIor", "IOR", "Index of refraction of iridescence layer", false),
+                    new Property(this, "_IridescenceThickness", "Thickness", "Iridescence thickness (Remap to 0..3000nm)", false),
+                }, _ => EnableIridescence.BoolValue == true),
-                new GroupProperty(this, "Transmission", new BaseProperty[]
+                new GroupProperty(this, "_SSS", "Sub-Surface Scattering", new BaseProperty[]
-                    new DiffusionProfileProperty(this, k_DiffusionProfileName, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false),
-                    new TextureProperty(this, k_ThicknessName, "Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.", false),
-                }),
+                    new DiffusionProfileProperty(this, k_DiffusionProfile, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false),
+                    new TextureProperty(this, k_SubsurfaceMaskMap, k_SubsurfaceMask, "Subsurface mask map (R)", "Determines the strength of the subsurface scattering effect.", false, false),
+                }, _ => EnableSSS.BoolValue == true ),
-                //new GroupProperty(this, "Iridescence", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Index of Refraction", "Index of Refraction for Iridescence", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Thickness", "Thickness", false),
-                //}),
+                new GroupProperty(this, "_Transmission", "Transmission", new BaseProperty[]
+                {
+                    new DiffusionProfileProperty(this, k_DiffusionProfile, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false, _ => EnableSSS.BoolValue == false),
+                    new TextureProperty(this, k_ThicknessMap, k_Thickness, "Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.", false),
+                }, _ => EnableTransmission.BoolValue == true),
-                //new GroupProperty(this, "Glint", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Density", "Density:", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Tint", "Tint", false),
-                //}),
+                new GroupProperty(this, "_Emissive", "Emissive", new BaseProperty[]
+                {
+                    new TextureProperty(this, k_EmissiveColorMap, k_EmissiveColor, "Emissive Color", "Emissive", true, false),
+                    new Property(this, k_EmissiveIntensity, "Emissive Intensity", "Emissive", false),
+                    new Property(this, k_AlbedoAffectEmissive, "Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.", false),
+                }),
+
+                new GroupProperty(this, "_Debug", "Debug", new BaseProperty[]
+                {
+                    new Property(this, "_DebugEnable", "Debug Enable", "Switch to a debug version of the shader", false),
+                    new Property(this, "_DebugLobeMask", "DebugLobeMask", "xyz is Lobe 0 1 2 Enable, w is Enable VLayering", false),
+                    new Property(this, "_DebugAniso", "DebugAniso", "x is Hack Enable, y is factor", false),
+                }),
             });
         }
 
         {
             //base.FindMaterialProperties(props);
             _materialProperties.OnFindProperty(props);
-            }
+        }
 
         protected override void BaseMaterialPropertiesGUI()
         {
 
         protected override void MaterialPropertiesGUI(Material material)
         {
+            //if (GUILayout.Button("Generate All Properties"))
+            //{
+            //    Debug.Log(_materialProperties.ToShaderPropertiesStringInternal());
+            //}
+
             _materialProperties.OnGUI();
         }
 
             SetupMaterialKeywordsAndPass(material);
         }
 
+        protected static void SetupTextureMaterialProperty(Material material, string basePropertyName)
+        {
+            // 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 channelPropertyName = basePropertyName + "MapChannel";
+            string channelMaskPropertyName = basePropertyName + "MapChannelMask";
+
+            if (material.GetTexture(mapPropertyName))
+            {
+                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.SetFloat(useMapPropertyName, 1.0f);
+                material.SetVector(rangePropertyName, rangeVector);
+
+                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;
+                }
+            }
+            else
+            {
+                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));
+            }
+        }
+
-        static public void SetupMaterialKeywordsAndPass(Material material)
+        public static void SetupMaterialKeywordsAndPass(Material material)
         {
             //TODO see BaseLitUI.cs:SetupBaseLitKeywords (stencil etc)
             SetupBaseUnlitKeywords(material);
 
             if (doubleSidedEnable)
             {
-                BaseLitGUI.DoubleSidedNormalMode doubleSidedNormalMode = (BaseLitGUI.DoubleSidedNormalMode)material.GetFloat(k_DoubleSidedNormalMode);
+                BaseLitGUI.DoubleSidedNormalMode doubleSidedNormalMode =
+                    (BaseLitGUI.DoubleSidedNormalMode) material.GetFloat(k_DoubleSidedNormalMode);
                 switch (doubleSidedNormalMode)
                 {
                     case BaseLitGUI.DoubleSidedNormalMode.Mirror: // Mirror mode (in tangent space)
                 }
             }
 
-            //NOTE: For SSS in forward and split lighting, obviously we don't have a gbuffer pass, 
-            // so no stencil tagging there, but velocity? To check...
-
             //TODO: stencil state, displacement, wind, depthoffset, tessellation
 
             SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
-            CoreUtils.SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", true);
-            CoreUtils.SetKeyword(material, "_NORMALMAP", material.GetTexture(k_NormalMap));
-            CoreUtils.SetKeyword(material, "_SMOOTHNESSMASKMAPA", material.GetTexture(k_Smoothness1Map));
-            CoreUtils.SetKeyword(material, "_SMOOTHNESSMASKMAPB", material.GetTexture(k_Smoothness2Map));
-            CoreUtils.SetKeyword(material, "_METALLICMAP", material.GetTexture(k_MetallicMap));
-            CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(k_EmissiveColorMap));
+            SetupTextureMaterialProperty(material, k_Metallic);
+            SetupTextureMaterialProperty(material, k_SmoothnessA);
+            SetupTextureMaterialProperty(material, k_SmoothnessB);
+            SetupTextureMaterialProperty(material, k_AmbientOcclusion);
+            SetupTextureMaterialProperty(material, k_SubsurfaceMask);
+            SetupTextureMaterialProperty(material, k_Thickness);
+            SetupTextureMaterialProperty(material, k_Anisotropy);
+            SetupTextureMaterialProperty(material, k_IridescenceThickness);
+            SetupTextureMaterialProperty(material, k_CoatSmoothness);
+
+            // Check if we are using specific UVs.
+            TextureProperty.UVMapping[] uvIndices = new[]
+            {
+                (TextureProperty.UVMapping) material.GetFloat(k_BaseColorMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_MetallicMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_NormalMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_SmoothnessAMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_SmoothnessBMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_AmbientOcclusionMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_EmissiveColorMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_SubsurfaceMaskMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_ThicknessMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_AnisotropyMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_IridescenceThicknessMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_CoatSmoothnessMapUV),
+            };
+
+            // Set keyword for mapping
+
+            //bool requireUv2 = false;
+            //bool requireUv3 = false;
+            bool requireTriplanar = false;
+            for (int i = 0; i < uvIndices.Length; ++i)
+            {
+                //requireUv2 = requireUv2 || uvIndices[i] == TextureProperty.UVMapping.UV2;
+                //requireUv3 = requireUv3 || uvIndices[i] == TextureProperty.UVMapping.UV3;
+                requireTriplanar = requireTriplanar || uvIndices[i] == TextureProperty.UVMapping.Triplanar;
+            }
+            CoreUtils.SetKeyword(material, "_USE_TRIPLANAR", requireTriplanar);
+
+            bool dualSpecularLobeEnabled = material.HasProperty(k_EnableDualSpecularLobe) && material.GetFloat(k_EnableDualSpecularLobe) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_DUAL_SPECULAR_LOBE", dualSpecularLobeEnabled);
+
+            bool anisotropyEnabled = material.HasProperty(k_EnableAnisotropy) && material.GetFloat(k_EnableAnisotropy) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_ANISOTROPY", anisotropyEnabled);
+
+            bool iridescenceEnabled = material.HasProperty(k_EnableIridescence) && material.GetFloat(k_EnableIridescence) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_IRIDESCENCE", iridescenceEnabled);
-            //bool needUV2 = (LitGUI.UVBaseMapping)material.GetFloat(k_UVBase) == LitGUI.UVBaseMapping.UV2;
-            //bool needUV3 = (LitGUI.UVBaseMapping)material.GetFloat(k_UVBase) == LitGUI.UVBaseMapping.UV3;
+            bool transmissionEnabled = material.HasProperty(k_EnableAnisotropy) && material.GetFloat(k_EnableAnisotropy) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", transmissionEnabled);
-            //if (needUV3)
-            //{
-            //    material.DisableKeyword("_REQUIRE_UV2");
-            //    material.EnableKeyword("_REQUIRE_UV3");
-            //}
-            //else if (needUV2)
-            //{
-            //    material.EnableKeyword("_REQUIRE_UV2");
-            //    material.DisableKeyword("_REQUIRE_UV3");
-            //}
-            //else
-            //{
-            //    material.DisableKeyword("_REQUIRE_UV2");
-            //    material.DisableKeyword("_REQUIRE_UV3");
-            //}
+            bool sssEnabled = material.HasProperty(k_EnableSubsurfaceScattering) && material.GetFloat(k_EnableSubsurfaceScattering) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", sssEnabled);
-            CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(k_EmissiveColorMap));
+            bool coatEnabled = material.HasProperty(k_EnableCoat) && material.GetFloat(k_EnableCoat) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_COAT", coatEnabled);
+
+            // TEMP - Remove once dev is finish
+            bool debugEnabled = material.HasProperty("_DebugEnable") && material.GetFloat("_DebugEnable") > 0.0f;
+            CoreUtils.SetKeyword(material, "_STACKLIT_DEBUG", debugEnabled);
+
+
+            // Set the reference value for the stencil test - required for SSS
+            int stencilRef = (int)StencilLightingUsage.RegularLighting;
+            if (sssEnabled)
+            {
+                stencilRef = (int)StencilLightingUsage.SplitLighting;
+            }
+
+            // As we tag both during velocity pass and Gbuffer pass we need a separate state and we need to use the write mask
+            material.SetInt(kStencilRef, stencilRef);
+            material.SetInt(kStencilWriteMask, (int)HDRenderPipeline.StencilBitMask.LightingMask);
+            material.SetInt(kStencilRefMV, (int)HDRenderPipeline.StencilBitMask.ObjectVelocity);
+            material.SetInt(kStencilWriteMaskMV, (int)HDRenderPipeline.StencilBitMask.ObjectVelocity);
         }
     }
 } // namespace UnityEditor

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/GlobalLightLoopSettingsUI.cs

             EditorGUILayout.PropertyField(d.planarReflectionCacheCompressed, _.GetContent("Compress Planar Reflection Probe Cache"));
             EditorGUILayout.PropertyField(d.planarReflectionCubemapSize, _.GetContent("Planar Reflection Texture Size"));
             EditorGUILayout.PropertyField(d.planarReflectionProbeCacheSize, _.GetContent("Planar Probe Cache Size"));
-            EditorGUILayout.PropertyField(d.maxPlanarReflectionProbes, _.GetContent("Max Planar Probe Per Frame"));
-            d.maxPlanarReflectionProbes.intValue = Mathf.Max(1, d.maxPlanarReflectionProbes.intValue);
             --EditorGUI.indentLevel;
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedGlobalLightLoopSettings.cs

         public SerializedProperty planarReflectionProbeCacheSize;
         public SerializedProperty planarReflectionCubemapSize;
         public SerializedProperty planarReflectionCacheCompressed;
-        public SerializedProperty maxPlanarReflectionProbes;
         public SerializedProperty skyReflectionSize;
         public SerializedProperty skyLightingOverrideLayerMask;
 
             planarReflectionProbeCacheSize = root.Find((GlobalLightLoopSettings s) => s.planarReflectionProbeCacheSize);
             planarReflectionCubemapSize = root.Find((GlobalLightLoopSettings s) => s.planarReflectionTextureSize);
             planarReflectionCacheCompressed = root.Find((GlobalLightLoopSettings s) => s.planarReflectionCacheCompressed);
-            maxPlanarReflectionProbes = root.Find((GlobalLightLoopSettings s) => s.maxPlanarReflectionProbes);
 
             skyReflectionSize = root.Find((GlobalLightLoopSettings s) => s.skyReflectionSize);
             skyLightingOverrideLayerMask = root.Find((GlobalLightLoopSettings s) => s.skyLightingOverrideLayerMask);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 
             RTHandles.Release(m_DebugColorPickerBuffer);
             RTHandles.Release(m_DebugFullScreenTempBuffer);
-            
+
             m_DebugScreenSpaceTracingData.Release();
 
             HDCamera.CleanUnused();
             // HD use specific GraphicsSettings
             GraphicsSettings.lightsUseLinearIntensity = true;
             GraphicsSettings.lightsUseColorTemperature = true;
+            // HD should always use the new batcher
+            //GraphicsSettings.useScriptableRenderPipelineBatching = true;
 
             SupportedRenderingFeatures.active = new SupportedRenderingFeatures()
             {
                 return false;
             }
 
+#if !UNITY_SWITCH
             // VR is not supported currently in HD
             if (XRSettings.isDeviceActive)
             {
             }
+#endif
 
             return true;
         }
+            // Note: If you add new platform in this function, think about adding support when building the player to in HDRPCustomBuildProcessor.cs
+
             if (!SystemInfo.supportsComputeShaders)
                 return false;
 
                 SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOne ||
                 SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOneD3D12 ||
-                SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan)
+                SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan ||
+                SystemInfo.graphicsDeviceType == (GraphicsDeviceType)22 /*GraphicsDeviceType.Switch*/)
             {
                 return true;
             }
                 {
                     cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, previousDepthPyramidRT);
                     cmd.SetGlobalVector(HDShaderIDs._DepthPyramidSize, new Vector4(
-                        previousDepthPyramidRT.referenceSize.x, 
-                        previousDepthPyramidRT.referenceSize.y, 
-                        1f / previousDepthPyramidRT.referenceSize.x, 
+                        previousDepthPyramidRT.referenceSize.x,
+                        previousDepthPyramidRT.referenceSize.y,
+                        1f / previousDepthPyramidRT.referenceSize.x,
-                        previousDepthPyramidRT.referenceSize.x / (float)previousDepthPyramidRT.rt.width, 
-                        previousDepthPyramidRT.referenceSize.y / (float)previousDepthPyramidRT.rt.height, 
-                        Mathf.Log(Mathf.Min(previousDepthPyramidRT.rt.width, previousDepthPyramidRT.rt.height), 2), 
+                        previousDepthPyramidRT.referenceSize.x / (float)previousDepthPyramidRT.rt.width,
+                        previousDepthPyramidRT.referenceSize.y / (float)previousDepthPyramidRT.rt.height,
+                        Mathf.Log(Mathf.Min(previousDepthPyramidRT.rt.width, previousDepthPyramidRT.rt.height), 2),
-                    
+
-                        previousColorPyramidRT.referenceSize.x, 
-                        previousColorPyramidRT.referenceSize.y, 
-                        1f / previousColorPyramidRT.referenceSize.x, 
+                        previousColorPyramidRT.referenceSize.x,
+                        previousColorPyramidRT.referenceSize.y,
+                        1f / previousColorPyramidRT.referenceSize.x,
-                        previousColorPyramidRT.referenceSize.x / (float)previousColorPyramidRT.rt.width, 
-                        previousColorPyramidRT.referenceSize.y / (float)previousColorPyramidRT.rt.height, 
-                        Mathf.Log(Mathf.Min(previousColorPyramidRT.rt.width, previousColorPyramidRT.rt.height), 2), 
+                        previousColorPyramidRT.referenceSize.x / (float)previousColorPyramidRT.rt.width,
+                        previousColorPyramidRT.referenceSize.y / (float)previousColorPyramidRT.rt.height,
+                        Mathf.Log(Mathf.Min(previousColorPyramidRT.rt.width, previousColorPyramidRT.rt.height), 2),
                         0.0f
                     ));
                 }
                     continue;
                 }
 
-                if (camera.cameraType != CameraType.Reflection)
-                    // TODO: Render only visible probes
-                    ReflectionSystem.RenderAllRealtimeViewerDependentProbesFor(ReflectionProbeType.PlanarReflection, camera);
+                if (camera.cameraType != CameraType.Reflection
+                    // Planar probes rendering is not currently supported for orthographic camera
+                    // Avoid rendering to prevent error log spamming
+                    && !camera.orthographic)
+                        // TODO: Render only visible probes
+                        ReflectionSystem.RenderAllRealtimeViewerDependentProbesFor(ReflectionProbeType.PlanarReflection, camera);
 
                 // Init material if needed
                 // TODO: this should be move outside of the camera loop but we have no command buffer, ask details to Tim or Julien to do this

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.cs

             {
                 return new ReflectionSystemParameters
                 {
-                    maxPlanarReflectionProbes = renderPipelineSettings.lightLoopSettings.maxPlanarReflectionProbes,
+                    maxPlanarReflectionProbePerCamera = renderPipelineSettings.lightLoopSettings.planarReflectionProbeCacheSize,
+                    maxActivePlanarReflectionProbe = 512,
                     planarReflectionProbeSize = renderPipelineSettings.lightLoopSettings.planarReflectionTextureSize
                 };
             }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

-// Each #kernel tells which function to compile; you can have many kernels
+// Each #kernel tells which function to compile; you can have many kernels
 #pragma kernel DeferredDirectionalShadow				    DEFERRED_DIRECTIONAL=DeferredDirectionalShadow
 #pragma kernel DeferredDirectionalShadow_Contact		    DEFERRED_DIRECTIONAL=DeferredDirectionalShadow_Contact	        ENABLE_CONTACT_SHADOWS
 #pragma kernel DeferredDirectionalShadow_Normals		    DEFERRED_DIRECTIONAL=DeferredDirectionalShadow_Normals          ENABLE_NORMALS
 #include "../ShaderVariables.hlsl"
 #include "Lighting.hlsl" 
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 //#pragma enable_d3d11_debug_symbols
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightEvaluation.hlsl

 // This files include various function uses to evaluate lights
-// To use deferred directional shadow with cascaded shadow map, 
+// To use deferred directional shadow with cascaded shadow map,
 // it is required to define USE_DEFERRED_DIRECTIONAL_SHADOWS before including this files
 
 //-----------------------------------------------------------------------------
     float3 indirectSpecularOcclusion;
 };
 
-void GetScreenSpaceAmbientOcclusion(float2 positionSS, float NdotV, float perceptualRoughness, float specularOcclusionFromData, out AmbientOcclusionFactor aoFactor)
+void GetScreenSpaceAmbientOcclusion(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, out AmbientOcclusionFactor aoFactor)
 {
     // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
     // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
     float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
     float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
 
-    aoFactor.indirectAmbientOcclusion   = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), indirectAmbientOcclusion);
+    aoFactor.indirectSpecularOcclusion  = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(specularOcclusionFromData, specularOcclusion));
+    aoFactor.indirectAmbientOcclusion   = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(ambientOcclusionFromData, indirectAmbientOcclusion));
-    aoFactor.indirectSpecularOcclusion  = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(specularOcclusionFromData, specularOcclusion));
-void GetScreenSpaceAmbientOcclusionMultibounce(float2 positionSS, float NdotV, float perceptualRoughness, float specularOcclusionFromData, float3 diffuseColor, float3 fresnel0, out AmbientOcclusionFactor aoFactor)
+void GetScreenSpaceAmbientOcclusionMultibounce(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, float3 diffuseColor, float3 fresnel0, out AmbientOcclusionFactor aoFactor)
 {
     // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the diffuseColor)
     // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
     float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
     float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
 
-    aoFactor.indirectAmbientOcclusion   = GTAOMultiBounce(indirectAmbientOcclusion, diffuseColor);
-    aoFactor.directAmbientOcclusion     = GTAOMultiBounce(min(specularOcclusionFromData, specularOcclusion), fresnel0);
-    aoFactor.indirectSpecularOcclusion  = GTAOMultiBounce(directAmbientOcclusion, diffuseColor);
+    aoFactor.indirectSpecularOcclusion  = GTAOMultiBounce(min(specularOcclusionFromData, specularOcclusion), fresnel0);
+    aoFactor.indirectAmbientOcclusion   = GTAOMultiBounce(min(ambientOcclusionFromData, indirectAmbientOcclusion), diffuseColor);
+    aoFactor.directAmbientOcclusion     = GTAOMultiBounce(directAmbientOcclusion, diffuseColor);
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

 #include "../../Debug/DebugDisplay.hlsl"
 #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 //-------------------------------------------------------------------------------------
 // variable declaration

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/GlobalLightLoopSettings.cs

         public int pointCookieSize = 128;
         public int cubeCookieTexArraySize = 16;
 
-        public int reflectionProbeCacheSize = 4;
+        public int reflectionProbeCacheSize = 2;
-        public int maxPlanarReflectionProbes = 128;
         public SkyResolution skyReflectionSize = SkyResolution.SkyResolution256;
         public LayerMask skyLightingOverrideLayerMask = 0;
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

-using System;
+using System;
 using System.Collections.Generic;
 using UnityEngine.Experimental.Rendering.HDPipeline.Internal;
 using UnityEngine.Rendering;
             m_lightList = new LightList();
             m_lightList.Allocate();
             m_Env2DCaptureVP.Clear();
-            for (int i = 0, c = Mathf.Max(1, hdAsset.renderPipelineSettings.lightLoopSettings.maxPlanarReflectionProbes); i < c; ++i)
+            for (int i = 0, c = Mathf.Max(1, hdAsset.renderPipelineSettings.lightLoopSettings.planarReflectionProbeCacheSize); i < c; ++i)
                 m_Env2DCaptureVP.Add(Matrix4x4.identity);
 
             m_DirectionalLightDatas = new ComputeBuffer(k_MaxDirectionalLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoopDef.hlsl

 #define SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES 0
 #define SINGLE_PASS_CONTEXT_SAMPLE_SKY 1
 
+bool IsEnvIndexCubemap(int index)   { return (index & 1) == ENVCACHETYPE_CUBEMAP; }
+bool IsEnvIndexTexture2D(int index) { return (index & 1) == ENVCACHETYPE_TEXTURE2D; }
+
 // Note: index is whatever the lighting architecture want, it can contain information like in which texture to sample (in case we have a compressed BC6H texture and an uncompressed for real time reflection ?)
 // EnvIndex can also be use to fetch in another array of struct (to  atlas information etc...).
 // Cubemap      : texCoord = direction vector

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/builddispatchindirect.compute

 #pragma kernel BuildDispatchIndirect
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "LightLoop.cs.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/cleardispatchindirect.compute

 #pragma kernel ClearDispatchIndirect
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 RWBuffer<uint> g_DispatchIndirectBuffer : register( u0 );	// Indirect arguments have to be in a _buffer_, not a structured buffer
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-bigtile.compute

 #include "SortingComputeUtils.hlsl"
 #include "LightCullUtils.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 #define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-clustered.compute

 #include "SortingComputeUtils.hlsl"
 #endif
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 //#define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild.compute

 #include "SortingComputeUtils.hlsl"
 #endif
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 #define FINE_PRUNING_ENABLED
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/materialflags.compute

-#pragma kernel MaterialFlagsGen_Write		MATERIALFLAGSGEN=MaterialFlagsGen_Write
+#pragma kernel MaterialFlagsGen_Write		MATERIALFLAGSGEN=MaterialFlagsGen_Write
 #pragma kernel MaterialFlagsGen_Or			MATERIALFLAGSGEN=MaterialFlagsGen_Or		USE_OR
 
 // #pragma enable_d3d11_debug_symbols
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 #include "../../Lighting/LightDefinition.cs.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 #define USE_MATERIAL_FEATURE_FLAGS
 #define NR_THREADS	64

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/scrbound.compute

 #include "LightLoop.cs.hlsl"
 #include "LightCullUtils.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ReflectionProbeCullResults.cs

 
         internal ReflectionProbeCullResults(ReflectionSystemParameters parameters)
         {
-            Assert.IsTrue(parameters.maxPlanarReflectionProbes >= 0, "Maximum number of planar reflection probe must be positive");
+            Assert.IsTrue(parameters.maxPlanarReflectionProbePerCamera >= 0, "Maximum number of planar reflection probe must be positive");
-            m_PlanarReflectionProbeIndices = new int[parameters.maxPlanarReflectionProbes];
-            m_VisiblePlanarReflectionProbes = new PlanarReflectionProbe[parameters.maxPlanarReflectionProbes];
+            m_PlanarReflectionProbeIndices = new int[parameters.maxPlanarReflectionProbePerCamera];
+            m_VisiblePlanarReflectionProbes = new PlanarReflectionProbe[parameters.maxPlanarReflectionProbePerCamera];
         }
 
         public void CullPlanarReflectionProbes(CullingGroup cullingGroup, PlanarReflectionProbe[] planarReflectionProbes)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ReflectionSystemInternal.cs

             m_Parameters = parameters;
 
             // Runtime collections
-            m_PlanarReflectionProbeBounds = new Dictionary<PlanarReflectionProbe, BoundingSphere>(parameters.maxPlanarReflectionProbes);
-            m_PlanarReflectionProbesArray = new PlanarReflectionProbe[parameters.maxPlanarReflectionProbes];
-            m_PlanarReflectionProbeBoundsArray = new BoundingSphere[parameters.maxPlanarReflectionProbes];
-            m_PlanarReflectionProbe_RealtimeUpdate_WorkArray = new PlanarReflectionProbe[parameters.maxPlanarReflectionProbes];
+            m_PlanarReflectionProbeBounds = new Dictionary<PlanarReflectionProbe, BoundingSphere>(parameters.maxActivePlanarReflectionProbe);
+            m_PlanarReflectionProbesArray = new PlanarReflectionProbe[parameters.maxActivePlanarReflectionProbe];
+            m_PlanarReflectionProbeBoundsArray = new BoundingSphere[parameters.maxActivePlanarReflectionProbe];
+            m_PlanarReflectionProbe_RealtimeUpdate_WorkArray = new PlanarReflectionProbe[parameters.maxPlanarReflectionProbePerCamera];
 
             // Persistent collections
             m_PlanarReflectionProbes = new HashSet<PlanarReflectionProbe>();
             var cullingGroup = new CullingGroup();
             cullingGroup.targetCamera = camera;
             cullingGroup.SetBoundingSpheres(m_PlanarReflectionProbeBoundsArray);
-            cullingGroup.SetBoundingSphereCount(m_PlanarReflectionProbeBounds.Count);
+            cullingGroup.SetBoundingSphereCount(Mathf.Min(m_PlanarReflectionProbeBounds.Count, m_PlanarReflectionProbeBoundsArray.Length));
 
             results.PrepareCull(cullingGroup, m_PlanarReflectionProbesArray);
         }
             if ((probeType & ReflectionProbeType.PlanarReflection) != 0)
             {
                 var length = Mathf.Min(m_PlanarReflectionProbe_PerCamera_RealtimeUpdate.Count, m_PlanarReflectionProbe_RealtimeUpdate_WorkArray.Length);
-                m_PlanarReflectionProbe_PerCamera_RealtimeUpdate.CopyTo(m_PlanarReflectionProbe_RealtimeUpdate_WorkArray);
+                var index = 0;
+                foreach (var p in m_PlanarReflectionProbe_PerCamera_RealtimeUpdate)
+                {
+                    m_PlanarReflectionProbe_RealtimeUpdate_WorkArray[index] = p;
+                    if (++index >= length)
+                        break;
+                }
+#if DEBUG
+                var discarded = m_PlanarReflectionProbe_PerCamera_RealtimeUpdate.Count - length;
+                if (discarded > 0)
+                    Debug.LogWarningFormat("There are more planar probe than supported in a single rendering, {0} probes discardeds", discarded);
+#endif
 
                 // 1. Allocate if necessary target texture
                 var renderCamera = GetRenderCamera();
                 foreach (var planarReflectionProbe in m_PlanarReflectionProbe_DirtyBounds)
                     UpdatePlanarReflectionProbeBounds(planarReflectionProbe);
 
-                m_PlanarReflectionProbeBounds.Values.CopyTo(m_PlanarReflectionProbeBoundsArray, 0);
-                m_PlanarReflectionProbeBounds.Keys.CopyTo(m_PlanarReflectionProbesArray, 0);
+                var length = m_PlanarReflectionProbeBoundsArray.Length;
+                var index = 0;
+                foreach (var k in m_PlanarReflectionProbeBounds)
+                {
+                    m_PlanarReflectionProbeBoundsArray[index] = k.Value;
+                    m_PlanarReflectionProbesArray[index] = k.Key;
+                    if (++index >= length)
+                        break;
+                }
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ReflectionSystemParameters.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
+    /// <summary>
+    /// Holds settings for the reflection system.
+    /// </summary>
-            maxPlanarReflectionProbes = 512,
+            maxPlanarReflectionProbePerCamera = 128,
+            maxActivePlanarReflectionProbe = 512,
-        public int maxPlanarReflectionProbes;
+        /// <summary>
+        /// Maximum number of planar reflection that can be found in a cull result.
+        /// </summary>
+        public int maxPlanarReflectionProbePerCamera;
+
+        /// <summary>
+        /// Maximum number of active planar reflection in the world.
+        /// </summary>
+        public int maxActivePlanarReflectionProbe;
+
+        /// <summary>
+        /// Size of the planar probe textures.
+        /// </summary>
         public int planarReflectionProbeSize;
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VolumetricLighting.compute

 #include "../Lighting.hlsl" // Includes Material.hlsl
 #include "../LightEvaluation.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.shader

     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
     //#pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/BuildProbabilityTables.compute

 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 #include "../../ShaderVariables.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 /* --- Input --- */
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/ComputeGgxIblSampleData.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 #ifdef SHADER_API_MOBILE
 #define MAX_IBL_SAMPLE_CNT 34

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/GGXConvolve.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma multi_compile _ USE_MIS
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLit.shader

     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DEPTHOFFSET_ON

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

     HLSLINCLUDE
 
     #pragma target 5.0
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DEPTHOFFSET_ON

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

-// SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
+// SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
 #include "Lit.cs.hlsl"
 #include "../SubsurfaceScattering/SubsurfaceScattering.hlsl"
 #include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
     return ((featureFlags & flag) != 0);
 }
 
-float3 ComputeDiffuseColor(float3 baseColor, float metallic)
-{
-    return baseColor * (1.0 - metallic);
-}
-
-float3 ComputeFresnel0(float3 baseColor, float metallic, float dielectricF0)
-{
-    return lerp(dielectricF0.xxx, baseColor, metallic);
-}
-
 // Assume that bsdfData.diffusionProfile is init
 void FillMaterialSSS(uint diffusionProfile, float subsurfaceMask, inout BSDFData bsdfData)
 {
     preLightData.transparentTransmittance = exp(-bsdfData.absorptionCoefficient * refraction.dist);
     // Empirical remap to try to match a bit the refraction probe blurring for the fallback
     // Use IblPerceptualRoughness so we can handle approx of clear coat.
-    preLightData.transparentSSMipLevel = sqrt(preLightData.iblPerceptualRoughness) * uint(_ColorPyramidScale.z);
+    preLightData.transparentSSMipLevel = pow(preLightData.iblPerceptualRoughness, 1.3) * uint(max(_ColorPyramidScale.z - 1, 0));
 #endif
 
     return preLightData;
 
             float3 rayOriginWS      = preLightData.transparentPositionWS;
             float3 rayDirWS         = preLightData.transparentRefractV;
-#if DEBUG_DISPLAY
+#ifdef DEBUG_DISPLAY
             int debugMode           = DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION;
             bool debug              = _DebugLightingMode == debugMode
                 && !any(int2(_MouseClickPixelCoord.xy) - int2(posInput.positionSS));
             // Common initialization
             ssRayInput.rayOriginWS = rayOriginWS;
             ssRayInput.rayDirWS = rayDirWS;
-#if DEBUG_DISPLAY
+#ifdef DEBUG_DISPLAY
             ssRayInput.debug = debug;
 #endif
             // Algorithm specific initialization
     float3 F = preLightData.specularFGD;
     float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);
 
+    // Specific case for Texture2Ds, their convolution is a gaussian one and not a GGX one.
+    // So we use another roughness mip mapping.
+    if (IsEnvIndexTexture2D(lightData.envIndex))
+    {
+        // Empirical remapping
+        iblMipLevel = PositivePow(preLightData.iblPerceptualRoughness, 0.8) * uint(max(_ColorPyramidScale.z - 1, 0));
+    }
+
     float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R, iblMipLevel);
     weight *= preLD.a; // Used by planar reflection to discard pixel
 
     AmbientOcclusionFactor aoFactor;
     // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the baseColor)
 #if 0
-    GetScreenSpaceAmbientOcclusion(posInput.positionSS, preLightData.NdotV, bsdfData.perceptualRoughness, bsdfData.specularOcclusion, aoFactor);
+    GetScreenSpaceAmbientOcclusion(posInput.positionSS, preLightData.NdotV, bsdfData.perceptualRoughness, 1.0, bsdfData.specularOcclusion, aoFactor);
-    GetScreenSpaceAmbientOcclusionMultibounce(posInput.positionSS, preLightData.NdotV, bsdfData.perceptualRoughness, bsdfData.specularOcclusion, bsdfData.diffuseColor, bsdfData.fresnel0, aoFactor);
+    GetScreenSpaceAmbientOcclusionMultibounce(posInput.positionSS, preLightData.NdotV, bsdfData.perceptualRoughness, 1.0, bsdfData.specularOcclusion, bsdfData.diffuseColor, bsdfData.fresnel0, aoFactor);
 #endif
 
     // Add indirect diffuse + emissive (if any) - Ambient occlusion is multiply by emissive which is wrong but not a big deal

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

-Shader "HDRenderPipeline/Lit"
+Shader "HDRenderPipeline/Lit"
 {
     Properties
     {
     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     //-------------------------------------------------------------------------------------
     // Variant

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

     HLSLINCLUDE
 
     #pragma target 5.0
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     //-------------------------------------------------------------------------------------
     // Variant

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.cs

         int m_refCounting;
 
         // For image based lighting
-        Material m_InitPreFGD;
+        Material m_PreIntegratedFGDMaterial;
         RenderTexture m_PreIntegratedFGD;
 
         PreIntegratedFGD()
 
             if (m_refCounting == 0)
             {
-                m_InitPreFGD = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
+                var hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
+                m_PreIntegratedFGDMaterial = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.preIntegratedFGD);
 
                 m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
                 m_PreIntegratedFGD.hideFlags = HideFlags.HideAndDontSave;
             if (m_isInit)
                 return;
 
-            using (new ProfilingSample(cmd, "Init PreFGD"))
+            using (new ProfilingSample(cmd, "PreIntegratedFGD Material Generation"))
-                CoreUtils.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
+                CoreUtils.DrawFullScreen(cmd, m_PreIntegratedFGDMaterial, new RenderTargetIdentifier(m_PreIntegratedFGD));
             }
 
             m_isInit = true;
 
             if (m_refCounting == 0)
             {
-                CoreUtils.Destroy(m_InitPreFGD);
+                CoreUtils.Destroy(m_PreIntegratedFGDMaterial);
                 CoreUtils.Destroy(m_PreIntegratedFGD);
 
                 m_isInit = false;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs

 using System;
 using UnityEngine.Rendering;
+//using System.Runtime.InteropServices;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
         public enum MaterialFeatureFlags
         {
-            LitStandard             = 1 << 0
+            StackLitStandard                = 1 << 0,
+            StackLitDualSpecularLobe        = 1 << 1,
+            StackLitAnisotropy              = 1 << 2,
+            StackLitCoat                    = 1 << 3,
+            StackLitIridescence             = 1 << 4,
+            StackLitSubsurfaceScattering    = 1 << 5,
+            StackLitTransmission            = 1 << 6,
         };
 
         //-----------------------------------------------------------------------------
             [SurfaceDataAttributes("Material Features")]
             public uint materialFeatures;
 
-            // Standard
+            // Bottom interface (2 lobes BSDF)
+            // Standard parametrization
-            
+
+            [SurfaceDataAttributes("Ambient Occlusion")]
+            public float ambientOcclusion;
+
+            [SurfaceDataAttributes("Metallic")]
+            public float metallic;
+
+            [SurfaceDataAttributes("IOR")]
+            public float dielectricIor;
+
+
+            // Dual specular lobe
             [SurfaceDataAttributes("Smoothness B")]
             public float perceptualSmoothnessB;
 
-            [SurfaceDataAttributes("Metallic")]
-            public float metallic;
+            // Anisotropic
+            [SurfaceDataAttributes("Tangent", true)]
+            public Vector3 tangentWS;
+
+            [SurfaceDataAttributes("Anisotropy")]
+            public float anisotropy; // anisotropic ratio(0->no isotropic; 1->full anisotropy in tangent direction, -1->full anisotropy in bitangent direction)
+
+            // Iridescence
+            [SurfaceDataAttributes("IridescenceIor")]
+            public float iridescenceIor;
+            [SurfaceDataAttributes("IridescenceThickness")]
+            public float iridescenceThickness;
+
+            // Top interface and media (clearcoat)
+            [SurfaceDataAttributes("Coat Smoothness")]
+            public float coatPerceptualSmoothness;
+            [SurfaceDataAttributes("Coat IOR")]
+            public float coatIor;
+            [SurfaceDataAttributes("Coat Thickness")]
+            public float coatThickness;
+            [SurfaceDataAttributes("Coat Extinction Coefficient")]
+            public Vector3 coatExtinction;
+            // SSS
+            [SurfaceDataAttributes("Diffusion Profile")]
+            public uint diffusionProfile;
+            [SurfaceDataAttributes("Subsurface Mask")]
+            public float subsurfaceMask;
+
+            // Transmission
+            // + Diffusion Profile
+            [SurfaceDataAttributes("Thickness")]
+            public float thickness;
-
+            // Bottom interface (2 lobes BSDF)
+            // Standard parametrization
+            public float ambientOcclusion;
+
+
+            // Dual specular lobe
+
+            // Anisotropic
+            [SurfaceDataAttributes("", true)]
+            public Vector3 tangentWS;
+            [SurfaceDataAttributes("", true)]
+            public Vector3 bitangentWS;
-            //public fixed float test[2];
+
+            // Top interface and media (clearcoat)
+            public float coatRoughness;
+            public float coatPerceptualRoughness;
+            public float coatIor;
+            public float coatThickness;
+            public Vector3 coatExtinction;
+
+            // iridescence
+            public float iridescenceIor;
+            public float iridescenceThickness;
+            // SSS
+            public uint diffusionProfile;
+            public float subsurfaceMask;
+            // Transmission
+            // + Diffusion Profile
+            public float thickness;
+            public bool useThickObjectMode; // Read from the diffusion profile
+            public Vector3 transmittance;   // Precomputation of transmittance
+
         //-----------------------------------------------------------------------------
         // Init precomputed textures
         //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+MaterialFeatureFlags:  static fields
 //
-#define MATERIALFEATUREFLAGS_LIT_STANDARD (1)
+#define MATERIALFEATUREFLAGS_STACK_LIT_STANDARD (1)
+#define MATERIALFEATUREFLAGS_STACK_LIT_DUAL_SPECULAR_LOBE (2)
+#define MATERIALFEATUREFLAGS_STACK_LIT_ANISOTROPY (4)
+#define MATERIALFEATUREFLAGS_STACK_LIT_COAT (8)
+#define MATERIALFEATUREFLAGS_STACK_LIT_IRIDESCENCE (16)
+#define MATERIALFEATUREFLAGS_STACK_LIT_SUBSURFACE_SCATTERING (32)
+#define MATERIALFEATUREFLAGS_STACK_LIT_TRANSMISSION (64)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData:  static fields
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1302)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1303)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1304)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1305)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1306)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC (1307)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_AMBIENT_OCCLUSION (1302)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC (1303)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IOR (1304)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1305)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1306)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1307)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1308)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1309)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1310)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1311)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1312)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1313)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_ROUGHNESS (1314)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1315)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1316)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1317)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1318)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1319)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1320)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData:  static fields
 #define DEBUGVIEW_STACKLIT_BSDFDATA_FRESNEL0 (1402)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1403)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1404)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1405)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1406)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX (1407)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1408)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1409)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1410)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1411)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1412)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_AMBIENT_OCCLUSION (1403)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1404)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1405)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1406)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1407)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX (1408)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_TANGENT_WS (1409)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_BITANGENT_WS (1410)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1411)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1412)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1413)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1414)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1415)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_ROUGHNESS (1416)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_PERCEPTUAL_ROUGHNESS (1417)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_IOR (1418)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_THICKNESS (1419)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_EXTINCTION (1420)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_IOR (1421)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_THICKNESS (1422)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSION_PROFILE (1423)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_SUBSURFACE_MASK (1424)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_THICKNESS (1425)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_USE_THICK_OBJECT_MODE (1426)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_TRANSMITTANCE (1427)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData
 // PackingRules = Exact
     float3 baseColor;
+    float ambientOcclusion;
+    float metallic;
+    float dielectricIor;
-    float metallic;
+    float3 tangentWS;
+    float anisotropy;
+    float iridescenceIor;
+    float iridescenceThickness;
+    float coatPerceptualSmoothness;
+    float coatIor;
+    float coatThickness;
+    float3 coatExtinction;
+    uint diffusionProfile;
+    float subsurfaceMask;
+    float thickness;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData
     uint materialFeatures;
     float3 diffuseColor;
     float3 fresnel0;
+    float ambientOcclusion;
+    float3 tangentWS;
+    float3 bitangentWS;
+    float coatRoughness;
+    float coatPerceptualRoughness;
+    float coatIor;
+    float coatThickness;
+    float3 coatExtinction;
+    float iridescenceIor;
+    float iridescenceThickness;
+    uint diffusionProfile;
+    float subsurfaceMask;
+    float thickness;
+    bool useThickObjectMode;
+    float3 transmittance;
 };
 
 //
             result = surfacedata.baseColor;
             needLinearToSRGB = true;
             break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_AMBIENT_OCCLUSION:
+            result = surfacedata.ambientOcclusion.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC:
+            result = surfacedata.metallic.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_IOR:
+            result = surfacedata.dielectricIor.xxx;
+            break;
         case DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL:
             result = surfacedata.normalWS * 0.5 + 0.5;
             break;
         case DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING:
             result = surfacedata.lobeMix.xxx;
             break;
-        case DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC:
-            result = surfacedata.metallic.xxx;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT:
+            result = surfacedata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY:
+            result = surfacedata.anisotropy.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR:
+            result = surfacedata.iridescenceIor.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS:
+            result = surfacedata.iridescenceThickness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_ROUGHNESS:
+            result = surfacedata.coatPerceptualSmoothness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR:
+            result = surfacedata.coatIor.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS:
+            result = surfacedata.coatThickness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT:
+            result = surfacedata.coatExtinction;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE:
+            result = GetIndexColor(surfacedata.diffusionProfile);
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK:
+            result = surfacedata.subsurfaceMask.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS:
+            result = surfacedata.thickness.xxx;
             break;
     }
 }
         case DEBUGVIEW_STACKLIT_BSDFDATA_FRESNEL0:
             result = bsdfdata.fresnel0;
             break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_AMBIENT_OCCLUSION:
+            result = bsdfdata.ambientOcclusion.xxx;
+            break;
         case DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS:
             result = bsdfdata.normalWS * 0.5 + 0.5;
             break;
         case DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX:
             result = bsdfdata.lobeMix.xxx;
             break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_TANGENT_WS:
+            result = bsdfdata.tangentWS * 0.5 + 0.5;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_BITANGENT_WS:
+            result = bsdfdata.bitangentWS * 0.5 + 0.5;
+            break;
         case DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT:
             result = bsdfdata.roughnessAT.xxx;
             break;
             break;
         case DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY:
             result = bsdfdata.anisotropy.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_ROUGHNESS:
+            result = bsdfdata.coatRoughness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_PERCEPTUAL_ROUGHNESS:
+            result = bsdfdata.coatPerceptualRoughness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_IOR:
+            result = bsdfdata.coatIor.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_THICKNESS:
+            result = bsdfdata.coatThickness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COAT_EXTINCTION:
+            result = bsdfdata.coatExtinction;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_IOR:
+            result = bsdfdata.iridescenceIor.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_THICKNESS:
+            result = bsdfdata.iridescenceThickness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSION_PROFILE:
+            result = GetIndexColor(bsdfdata.diffusionProfile);
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_SUBSURFACE_MASK:
+            result = bsdfdata.subsurfaceMask.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_THICKNESS:
+            result = bsdfdata.thickness.xxx;
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_USE_THICK_OBJECT_MODE:
+            result = (bsdfdata.useThickObjectMode) ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);
+            break;
+        case DEBUGVIEW_STACKLIT_BSDFDATA_TRANSMITTANCE:
+            result = bsdfdata.transmittance;
             break;
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader

         // Reminder. Color here are in linear but the UI (color picker) do the conversion sRGB to linear
         // Be careful, do not change the name here to _Color. It will conflict with the "fake" parameters (see end of properties) required for GI.
         _BaseColor("BaseColor", Color) = (1,1,1,1)
-        _BaseColorMap("BaseColorMap", 2D) = "white" {}
-        _BaseColorMapUV("BaseColorMapUV", Float) = 0.0
+        _BaseColorMap("BaseColor Map", 2D) = "white" {}
+        [HideInInspector] _BaseColorMapShow("BaseColor Map Show", Float) = 0
+        _BaseColorMapUV("BaseColor Map UV", Float) = 0.0
+        _BaseColorMapUVLocal("BaseColorMap UV Local", Float) = 0.0
+        [HideInInspector] _MetallicMapShow("Metallic Map Show", Float) = 0
-        _MetallicMap("MetallicMap", 2D) = "black" {}
-        _MetallicMapUV("MetallicMapUV", Float) = 0.0
-        _MetallicMapChannel("MetallicMapChannel", Vector) = (1, 0, 0, 0)
+        _MetallicMap("Metallic Map", 2D) = "black" {}
+        _MetallicUseMap("Metallic Use Map", Float) = 0
+        _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)
-        [ToggleUI] _MetallicRemapInverted("Invert Metallic Remap", Float) = 0.0
+        [HideInInspector] _MetallicRange("Metallic Range", Vector) = (0, 1, 0, 0)
+        _DielectricIor("DielectricIor IOR", Range(1.0, 2.5)) = 1.5
+
+        [HideInInspector] _SmoothnessAMapShow("SmoothnessA Map Show", Float) = 0
-        _SmoothnessAMap("BaseColorMap", 2D) = "white" {}
-        _SmoothnessAMapUV("SmoothnessAMapUV", Float) = 0.0
-        _SmoothnessAMapChannel("SmoothnessA Map Channel", Vector) = (1, 0, 0, 0)
+        _SmoothnessAMap("SmoothnessA Map", 2D) = "white" {}
+        _SmoothnessAUseMap("SmoothnessA Use Map", Float) = 0
+        _SmoothnessAMapUV("SmoothnessA Map UV", Float) = 0.0
+        _SmoothnessAMapUVLocal("_SmoothnessA Map UV Local", Float) = 0.0
+        _SmoothnessAMapChannel("SmoothnessA Map Channel", Float) = 0.0
+        _SmoothnessAMapChannelMask("SmoothnessA Map Channel Mask", Vector) = (1, 0, 0, 0)
+        [HideInInspector] _SmoothnessARange("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
-        _SmoothnessBMap("SmoothnessBMap", 2D) = "white" {}
-        _SmoothnessBMapUV("SmoothnessBMapUV", Float) = 0.0
-        _SmoothnessBMapChannel("SmoothnessB Map Channel", Vector) = (1, 0, 0, 0)
+        _SmoothnessBMap("SmoothnessB Map", 2D) = "white" {}
+        _SmoothnessBUseMap("SmoothnessB Use Map", 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)
+        [HideInInspector] _SmoothnessBRange("SmoothnessB Range", Vector) = (0, 1, 0, 0)
+        [ToggleUI] _DebugEnable("Debug Enable", Float) = 0.0 // UI only
+        _DebugLobeMask("DebugLobeMask", Vector) = (1, 1, 1, 1)
+        _DebugAniso("DebugAniso", Vector) = (1, 0, 0, 1000.0)
+
+        // TODO: TangentMap, AnisotropyMap and CoatIorMap (SmoothnessMap ?)
+
+        [ToggleUI] _EnableAnisotropy("Enable Anisotropy", Float) = 0.0 // UI only
+        _Anisotropy("Anisotropy", Range(-1.0, 1.0)) = 0.0
+        _AnisotropyMap("Anisotropy Map", 2D) = "white" {}
+        _AnisotropyUseMap("Anisotropy Use Map", Float) = 0
+        _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)
+
+        [ToggleUI] _EnableCoat("Enable Coat", Float) = 0.0 // UI only
+        [HideInInspector] _CoatSmoothnessMapShow("CoatSmoothness Show", Float) = 0
+        _CoatSmoothness("CoatSmoothness", Range(0.0, 1.0)) = 1.0
+        _CoatSmoothnessMap("CoatSmoothness Map", 2D) = "white" {}
+        _CoatSmoothnessUseMap("CoatSmoothness Use Map", 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)
+
+        _CoatIor("Coat IOR", Range(1.0001, 2.0)) = 1.5
+        _CoatThickness("Coat Thickness", Range(0.0, 0.99)) = 0.0
+        _CoatExtinction("Coat Extinction Coefficient", Color) = (1,1,1) // in thickness^-1 units
+
+        [HideInInspector] _NormalMapShow("NormalMap Show", Float) = 0.0
-        _NormalScale("_NormalScale", Range(0.0, 2.0)) = 1
+        _NormalMapUVLocal("NormalMapUV Local", Float) = 0.0
+        _NormalMapObjSpace("NormalMapUV Local", Float) = 0.0
+        _NormalScale("Normal Scale", Range(0.0, 2.0)) = 1
-        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVBase("UV Set for base", Float) = 0
-        [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
+        [HideInInspector] _AmbientOcclusionMapShow("AmbientOcclusion Map Show", Float) = 0
+        _AmbientOcclusion("AmbientOcclusion", Range(0.0, 1.0)) = 1
+        _AmbientOcclusionMap("AmbientOcclusion Map", 2D) = "white" {}
+        _AmbientOcclusionUseMap("AmbientOcclusion Use Map", 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)
-        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
-        _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
-        _EmissiveColorMapUV("EmissiveColorMap", Range(0.0, 1.0)) = 0
-        _EmissiveIntensity("EmissiveIntensity", Float) = 0
+        [HideInInspector] _EmissiveColorMapShow("Emissive Color Map Show", Float) = 0.0
+        _EmissiveColor("Emissive Color", Color) = (1, 1, 1)
+        _EmissiveColorMap("Emissive Color Map", 2D) = "white" {}
+        _EmissiveColorMapUV("Emissive Color Map UV", Range(0.0, 1.0)) = 0
+        _EmissiveColorMapUVLocal("Emissive Color Map UV Local", Float) = 0.0
+        _EmissiveIntensity("Emissive Intensity", Float) = 0
+        [ToggleUI] _EnableSubsurfaceScattering("Enable Subsurface Scattering", Float) = 0.0
+        _DiffusionProfile("Diffusion Profile", Int) = 0
+        [HideInInspector] _SubsurfaceMaskMapShow("Subsurface Mask Map Show", Float) = 0
+        _SubsurfaceMask("Subsurface Mask", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMaskMap("Subsurface Mask Map", 2D) = "black" {}
+        _SubsurfaceMaskUseMap("Subsurface Mask Use Map", Float) = 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)
+
+        [ToggleUI] _EnableTransmission("Enable Transmission", Float) = 0.0
+        [HideInInspector] _ThicknessMapShow("Thickness Show", Float) = 0
+        _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
+        _ThicknessMap("Thickness Map", 2D) = "black" {}
+        _ThicknessUseMap("Thickness Use Map", 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)
+
+        [ToggleUI] _EnableIridescence("Enable Iridescence", Float) = 0.0 // UI only
+        _IridescenceIor("Coat IOR", Range(1.0, 2.0)) = 1.5
+        _IridescenceThickness("_IridescenceThickness", Range(0.0, 1.0)) = 0.0
+        _IridescenceThicknessMap("IridescenceThickness Color Map", 2D) = "black" {}
+        _IridescenceThicknessUseMap("IridescenceThickness Use Map", Float) = 0
+        _IridescenceThicknessMapUV("IridescenceThickness Map UV", Float) = 0.0
+        _IridescenceThicknessMapLocal("IridescenceThickness Map UV Local", Float) = 0.0
+        _IridescenceThicknessMapChannel("IridescenceThickness Mask Map Channel", Float) = 0.0
+        _IridescenceThicknessMapChannelMask("IridescenceThickness Mask Map Channel Mask", Vector) = (1, 0, 0, 0)
+        [HideInInspector] _IridescenceThicknessRange("IridescenceThickness Range", Vector) = (0, 1, 0, 0)
+
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
         [ToggleUI] _DistortionEnable("Enable Distortion", Float) = 0.0
         [ToggleUI] _DistortionOnly("Distortion Only", Float) = 0.0
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
         _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
-
         // Stencil state
         [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting  (fixed at compile time)
         [HideInInspector] _StencilWriteMask("_StencilWriteMask", Int) = 7 // StencilMask.Lighting  (fixed at compile time)
 
         [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 1.0
         [ToggleUI] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0
-        
+
+
+
+        // Sections show values.
+        [HideInInspector] _MaterialFeaturesShow("_MaterialFeaturesShow", Float) = 1.0
+        [HideInInspector] _StandardShow("_StandardShow", Float) = 0.0
+        [HideInInspector] _EmissiveShow("_EmissiveShow", Float) = 0.0
+        [HideInInspector] _CoatShow("_CoatShow", Float) = 0.0
+        [HideInInspector] _DebugShow("_DebugShow", Float) = 0.0
+        [HideInInspector] _SSSShow("_SSSShow", Float) = 0.0
+        [HideInInspector] _DualSpecularLobeShow("_DualSpecularLobeShow", Float) = 0.0
+        [HideInInspector] _AnisotropyShow("_AnisotropyShow", Float) = 0.0
+        [HideInInspector] _TransmissionShow("_TransmissionShow", Float) = 0.0
+        [HideInInspector] _IridescenceShow("_IridescenceShow", Float) = 0.0
 
         // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
         // value that exist to identify if the GI emission need to be enabled.
     #pragma shader_feature _DOUBLESIDED_ON
 
     #pragma shader_feature _NORMALMAP_TANGENT_SPACE
-    #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3 
-    // ...TODO: for surface gradient framework eg see litdata.hlsl, 
-    // but we need it right away for toggle with LayerTexCoord mapping so we might need them 
+    #pragma shader_feature _USE_UV2
+    #pragma shader_feature _USE_UV3
+    #pragma shader_feature _USE_TRIPLANAR
+    // ...TODO: for surface gradient framework eg see litdata.hlsl,
+    // but we need it right away for toggle with LayerTexCoord mapping so we might need them
-    #pragma shader_feature _NORMALMAP
-    #pragma shader_feature _MASKMAPA
-    #pragma shader_feature _MASKMAPB
-    #pragma shader_feature _EMISSIVE_COLOR_MAP
-
-    
+
+    // MaterialFeature are used as shader feature to allow compiler to optimize properly
+    #pragma shader_feature _MATERIAL_FEATURE_DUAL_SPECULAR_LOBE
+    #pragma shader_feature _MATERIAL_FEATURE_ANISOTROPY
+    #pragma shader_feature _MATERIAL_FEATURE_COAT
+    #pragma shader_feature _MATERIAL_FEATURE_IRIDESCENCE
+    #pragma shader_feature _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
+    #pragma shader_feature _MATERIAL_FEATURE_TRANSMISSION
+
+
+    #pragma shader_feature _STACKLIT_DEBUG
     //enable GPU instancing support
     #pragma multi_compile_instancing
 
 
     #define UNITY_MATERIAL_STACKLIT // Need to be define before including Material.hlsl
+
+    // If we use subsurface scattering, enable output split lighting (for forward pass)
+    #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
+    #define OUTPUT_SPLIT_LIGHTING
+    #endif
 
     //-------------------------------------------------------------------------------------
     // Include
             ZWrite [_ZWrite]
             Cull [_CullModeForward]
             //
-            // NOTE: For _CullModeForward, see BaseLitUI and the handling of TransparentBackfaceEnable: 
+            // NOTE: For _CullModeForward, see BaseLitUI and the handling of TransparentBackfaceEnable:
             // Basically, we need to use it to support a TransparentBackface pass before this pass
             // (and it should be placed just before this one) for separate backface and frontface rendering,
             // eg for "hair shader style" approximate sorting, see eg Thorsten Scheuermann writeups on this:
             //
-            // See Lit.shader and the order of the passes after a DistortionVectors, we have: 
+            // See Lit.shader and the order of the passes after a DistortionVectors, we have:
             // TransparentDepthPrepass, TransparentBackface, Forward, TransparentDepthPostpass
 
             HLSLPROGRAM

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl

 #include "../MaterialUtilities.hlsl"
 
 //-----------------------------------------------------------------------------
-// Texture Mapping (think of LayerTexCoord as simply TexCoordMappings, 
-// ie no more layers here - cf Lit materials)
+// Texture Mapping
-//
-// For easier copying of code for now use a LayerTexCoord wrapping struct.
-// We don't have details yet.
-//
-// NEWLITTODO: Eventually, we could quickly share GetBuiltinData of LitBuiltinData.hlsl 
-// in our GetSurfaceAndBuiltinData( ) here, since we will use the LayerTexCoord identifier,
-// and an identical ComputeLayerTexCoord( ) prototype
-//
-struct LayerTexCoord
+#define TEXCOORD_INDEX_UV0          (0)
+#define TEXCOORD_INDEX_UV1          (1)
+#define TEXCOORD_INDEX_UV2          (2)
+#define TEXCOORD_INDEX_UV3          (3)
+#define TEXCOORD_INDEX_PLANAR_XY    (4)
+#define TEXCOORD_INDEX_PLANAR_YZ    (5)
+#define TEXCOORD_INDEX_PLANAR_ZX    (6)
+#define TEXCOORD_INDEX_TRIPLANAR    (7)
+#define TEXCOORD_INDEX_COUNT        (TEXCOORD_INDEX_TRIPLANAR) // Triplanar is not consider as having mapping
+
+struct TextureUVMapping
-    UVMapping base;
-    UVMapping details;
+    float2 texcoords[TEXCOORD_INDEX_COUNT][2];
+#ifdef _USE_TRIPLANAR
+    float3 triplanarWeights[2];
+#endif
-    // Store information that will be share by all UVMapping
-    float3 vertexNormalWS; // TODO: store also object normal map for object triplanar
+    float3 vertexNormalWS;
+    float3 vertexTangentWS[4];
+    float3 vertexBitangentWS[4];
-// Want to use only one sampler for normalmap/bentnormalmap either we use OS or TS. And either we have normal map or bent normal or both.
-// 
-// Note (compared to Lit shader): 
-//
-// We don't have a layered material with which we are sharing code here like the LayeredLit shader, but we can also save a couple of 
-// samplers later if we use bentnormals.
-//
-// _IDX suffix is meaningless here, could use the name SAMPLER_NORMALMAP_ID instead of SAMPLER_NORMALMAP_IDX and replace all 
-// indirect #ifdef _NORMALMAP_TANGENT_SPACE_IDX #ifdef and _NORMALMAP_IDX tests with the more direct 
-// shader_feature keywords _NORMALMAP_TANGENT_SPACE and _NORMALMAP.
-//
-// (Originally in the LayeredLit shader, shader_feature keywords like _NORMALMAP become _NORMALMAP0 but since files are shared,
-// LitDataIndividualLayer will use a generic _NORMALMAP_IDX defined before its inclusion by the client LitData or LayeredLitData.
-// That way, LitDataIndividualLayer supports multiple inclusions)
-//
-// 
-#ifdef _NORMALMAP_TANGENT_SPACE
-    #if defined(_NORMALMAP)
-    #define SAMPLER_NORMALMAP_ID sampler_NormalMap
-    // TODO:
-    //#elif defined(_BENTNORMALMAP)
-    //#define SAMPLER_NORMALMAP_ID sampler_BentNormalMap
-    #endif
-#else
-    // TODO:
-    //#error STACKLIT_USES_ONLY_TANGENT_SPACE_FOR_NOW
-    //#if defined(_NORMALMAP)
-    //#define SAMPLER_NORMALMAP_ID sampler_NormalMapOS
-    //#elif defined(_BENTNORMALMAP)
-    //#define SAMPLER_NORMALMAP_ID sampler_BentNormalMapOS
-    //#endif
+void InitializeMappingData(FragInputs input, out TextureUVMapping uvMapping)
+{
+    float3 position = GetAbsolutePositionWS(input.positionWS);
+    float2 uvXZ;
+    float2 uvXY;
+    float2 uvZY;
+
+    // Build the texcoords array.
+    uvMapping.texcoords[TEXCOORD_INDEX_UV0][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV0][1] = input.texCoord0.xy;
+    uvMapping.texcoords[TEXCOORD_INDEX_UV1][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV1][1] = input.texCoord1.xy;
+    uvMapping.texcoords[TEXCOORD_INDEX_UV2][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV2][1] = input.texCoord2.xy;
+    uvMapping.texcoords[TEXCOORD_INDEX_UV3][0] = uvMapping.texcoords[TEXCOORD_INDEX_UV3][1] = input.texCoord3.xy;
+
+    // planar/triplanar
+    GetTriplanarCoordinate(position, uvXZ, uvXY, uvZY);
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_XY][0] = uvXY;
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_YZ][0] = uvZY;
+    uvMapping.texcoords[TEXCOORD_INDEX_PLANAR_ZX][0] = uvXZ;
+
+    // If we use local planar mapping, convert to local space
+    position = TransformWorldToObject(position);
+    GetTriplanarCoordinate(position, 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;
+
+#ifdef _USE_TRIPLANAR
+    float3 vertexNormal = input.worldToTangent[2].xyz;
+    uvMapping.triplanarWeights[0] = ComputeTriplanarWeights(vertexNormal);
+    // If we use local planar mapping, convert to local space
+    vertexNormal = TransformWorldToObjectDir(vertexNormal);
+    uvMapping.triplanarWeights[1] = ComputeTriplanarWeights(vertexNormal);
-void ComputeLayerTexCoord( // Uv related parameters
-                                    float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 uvMappingMask, 
-                                    // scale and bias for base 
-                                    float2 texScale, float2 texBias, 
-                                    // mapping type and output
-                                    int mappingType, inout LayerTexCoord layerTexCoord)
-{
+    // Normal mapping with surface gradient
+    float3 vertexNormalWS = input.worldToTangent[2];
+    uvMapping.vertexNormalWS = vertexNormalWS;
+
+    uvMapping.vertexTangentWS[0] = input.worldToTangent[0];
+    uvMapping.vertexBitangentWS[0] = input.worldToTangent[1];
-    //TODO: Planar, Triplanar, detail map, surface_gradient.
+    float3 dPdx = ddx_fine(input.positionWS);
+    float3 dPdy = ddy_fine(input.positionWS);
-    // Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1)
-    float2 uvBase = uvMappingMask.x * texCoord0 +
-                    uvMappingMask.y * texCoord1 +
-                    uvMappingMask.z * texCoord2 +
-                    uvMappingMask.w * texCoord3;
-    
-    // Copy data in uvmapping fields: used by generic sampling code (see especially SampleUVMappingNormalInternal.hlsl)
-    layerTexCoord.base.mappingType = mappingType;
-    layerTexCoord.base.normalWS = layerTexCoord.vertexNormalWS;
+    float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
+    float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
+    //float flipSign = dot(sigmaY, cross(vertexNormalWS, sigmaX) ) ? -1.0 : 1.0;
+    float flipSign = dot(dPdy, cross(vertexNormalWS, dPdx)) < 0.0 ? -1.0 : 1.0; // gives same as the commented out line above
-    // Apply tiling options
-    layerTexCoord.base.uv = uvBase * texScale + texBias;
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord1, uvMapping.vertexTangentWS[1], uvMapping.vertexBitangentWS[1]);
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord2, uvMapping.vertexTangentWS[2], uvMapping.vertexBitangentWS[2]);
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord3, uvMapping.vertexTangentWS[3], uvMapping.vertexBitangentWS[3]);
+float4 SampleTexture2DScaleBias(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, TextureUVMapping uvMapping)
+{
+    return SAMPLE_TEXTURE2D(textureName, samplerName, (uvMapping.texcoords[textureNameUV][textureNameUVLocal] * textureNameST.xy + textureNameST.zw));
+}
-
-float3 GetNormalTS(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask)
+// If we use triplanar on any of the properties, then we enable the triplanar path
+float4 SampleTexture2DTriplanarScaleBias(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, TextureUVMapping uvMapping)
-    // TODO: different spaces (eg #ifdef _NORMALMAP_TANGENT_SPACE #elif object space, SURFACE_GRADIENT, etc.)
-    // and use detail map
+#ifdef _USE_TRIPLANAR
+    if (textureNameUV == TEXCOORD_INDEX_TRIPLANAR)
+    {
+        float4 val = float4(0.0, 0.0, 0.0, 0.0);
-    float3 normalTS;
+        if (uvMapping.triplanarWeights[textureNameUVLocal].x > 0.0)
+            val += uvMapping.triplanarWeights[textureNameUVLocal].x * SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), TEXCOORD_INDEX_PLANAR_YZ, textureNameUVLocal, textureNameST, uvMapping);
+        if (uvMapping.triplanarWeights[textureNameUVLocal].y > 0.0)
+            val += uvMapping.triplanarWeights[textureNameUVLocal].y * SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), TEXCOORD_INDEX_PLANAR_ZX, textureNameUVLocal, textureNameST, uvMapping);
+        if (uvMapping.triplanarWeights[textureNameUVLocal].z > 0.0)
+            val += uvMapping.triplanarWeights[textureNameUVLocal].z * SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), TEXCOORD_INDEX_PLANAR_XY, textureNameUVLocal, textureNameST, uvMapping);
-    // Note we don't use the _NORMALMAP_IDX mechanism of the Lit shader, since we don't have "layers", we can 
-    // directly use the shader_feature keyword:
-#ifdef _NORMALMAP
-        normalTS = SAMPLE_UVMAPPING_NORMALMAP(_NormalMap, SAMPLER_NORMALMAP_ID, layerTexCoord.base, _NormalScale);
-#else
-    normalTS = float3(0.0, 0.0, 1.0);
+        return val;
+    }
+    else
+    {
+#endif // _USE_TRIPLANAR
+        return SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), textureNameUV, textureNameUVLocal, textureNameST, uvMapping);
+#ifdef _USE_TRIPLANAR
+    }
-
-    return normalTS;
-// This maybe call directly by tessellation (domain) shader, thus all part regarding surface gradient must be done
-// 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 SampleTexture2DTriplanarNormalScaleBias(TEXTURE2D_ARGS(textureName, samplerName), float textureNameUV, float textureNameUVLocal, float4 textureNameST, float textureNameObjSpace, TextureUVMapping uvMapping, float2 scale)
-    layerTexCoord.vertexNormalWS = vertexNormalWS;
-    // TODO: 
-    //layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
+    if (textureNameObjSpace)
+    {
+        // TODO: obj triplanar (need to do * 2 - 1 before blending)
-    int mappingType = UV_MAPPING_UVSET;
+        // We forbid scale in case of object space as it make no sense
+        // Decompress normal ourselve
+        float3 normalOS = SampleTexture2DTriplanarScaleBias(TEXTURE2D_PARAM(textureName, samplerName), textureNameUV, textureNameUVLocal, textureNameST, uvMapping).xyz * 2.0 - 1.0;
+        // no need to renormalize normalOS for SurfaceGradientFromPerturbedNormal
+        return SurfaceGradientFromPerturbedNormal(uvMapping.vertexNormalWS, TransformObjectToWorldDir(normalOS));
+    }
+    else
+    {
+#ifdef _USE_TRIPLANAR
+        if (textureNameUV == TEXCOORD_INDEX_TRIPLANAR)
+        {
+            float2 derivXplane;
+            float2 derivYPlane;
+            float2 derivZPlane;
+            derivXplane = derivYPlane = derivZPlane = float2(0.0, 0.0);
-    //TODO: _MAPPING_PLANAR, _MAPPING_TRIPLANAR
+            if (uvMapping.triplanarWeights[textureNameUVLocal].x > 0.0)
+                derivXplane = uvMapping.triplanarWeights[textureNameUVLocal].x * UnpackDerivativeNormalRGorAG(SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), TEXCOORD_INDEX_PLANAR_YZ, textureNameUVLocal, textureNameST, uvMapping), scale);
+            if (uvMapping.triplanarWeights[textureNameUVLocal].y > 0.0)
+                derivYPlane = uvMapping.triplanarWeights[textureNameUVLocal].y * UnpackDerivativeNormalRGorAG(SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), TEXCOORD_INDEX_PLANAR_ZX, textureNameUVLocal, textureNameST, uvMapping), scale);
+            if (uvMapping.triplanarWeights[textureNameUVLocal].z > 0.0)
+                derivZPlane = uvMapping.triplanarWeights[textureNameUVLocal].z * UnpackDerivativeNormalRGorAG(SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), TEXCOORD_INDEX_PLANAR_XY, textureNameUVLocal, textureNameST, uvMapping), scale);
+
+            // Assume derivXplane, derivYPlane and derivZPlane sampled using (z,y), (z,x) and (x,y) respectively.
+            float3 volumeGrad = float3(derivZPlane.x + derivYPlane.y, derivZPlane.y + derivXplane.y, derivXplane.x + derivYPlane.x);
+            return SurfaceGradientFromVolumeGradient(uvMapping.vertexNormalWS, volumeGrad);
+        }
+#endif
-    // 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, /* TODO _UVDetailsMappingMask, */
-                            _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, /* TODO _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase,
-                            /* TODO positionWS, _TexWorldScale, */
-                            mappingType, layerTexCoord);
-}
+        float2 deriv = UnpackDerivativeNormalRGorAG(SampleTexture2DScaleBias(TEXTURE2D_PARAM(textureName, samplerName), textureNameUV, textureNameUVLocal, textureNameST, uvMapping));
-// This is call only in this file
-// layerTexCoord must have been initialize to 0 outside of this function
-void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
-{
-// TODO: SURFACE_GRADIENT
-//#ifdef SURFACE_GRADIENT
-    //GenerateLayerTexCoordBasisTB(input, layerTexCoord);
-//#endif
+        if (textureNameUV <= TEXCOORD_INDEX_UV3)
+        {
+            return SurfaceGradientFromTBN(deriv, uvMapping.vertexTangentWS[textureNameUV], uvMapping.vertexBitangentWS[textureNameUV]);
+        }
+        else
+        {
+            float3  volumeGrad;
+            if (textureNameUV == TEXCOORD_INDEX_PLANAR_YZ)
+                volumeGrad = float3(0.0, deriv.y, deriv.x);
+            else if (textureNameUV == TEXCOORD_INDEX_PLANAR_ZX)
+                volumeGrad = float3(deriv.y, 0.0, deriv.x);
+            else if (textureNameUV == TEXCOORD_INDEX_PLANAR_XY)
+                volumeGrad = float3(deriv.x, deriv.y, 0.0);
-    GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
-                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
+            return SurfaceGradientFromVolumeGradient(uvMapping.vertexNormalWS, volumeGrad);
+        }
+    }
+#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)
+
-// ...Texture Mapping
+// GetSurfaceAndBuiltinData
-// cf with 
+// cf with
-//    LitBuiltinData.hlsl:GetBuiltinData() 
+//    LitBuiltinData.hlsl:GetBuiltinData()
-    ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal
+    ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal.
-
-    LayerTexCoord layerTexCoord;
-    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
-    GetLayerTexCoord(input, layerTexCoord);
+    TextureUVMapping uvMapping;
+    InitializeMappingData(input, uvMapping);
-    // Surface Data:
+    // Surface Data
-    // We perform the conversion to world of the normalTS outside of the GetSurfaceData
-    // so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders
-    float3 normalTS;
-    // TODO: Those are only needed once we handle specular occlusion and optionnally bent normal maps.
-    // Also, for the builtinData part, use bentnormal to sample diffuse GI
-    //float3 bentNormalTS;
-    //float3 bentNormalWS;
-
-    //float alpha = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, baseColorMapUv).a * _BaseColor.a;
-    float alpha = SAMPLE_UVMAPPING_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, layerTexCoord.base).a * _BaseColor.a;
+    float alpha = SAMPLE_TEXTURE2D_SCALE_BIAS(_BaseColorMap).a * _BaseColor.a;
 #ifdef _ALPHATEST_ON
     //NEWLITTODO: Once we include those passes in the main StackLit.shader, add handling of CUTOFF_TRANSPARENT_DEPTH_PREPASS and _POSTPASS
     // and the related properties (in the .shader) and uniforms (in the StackLitProperties file) _AlphaCutoffPrepass, _AlphaCutoffPostpass
-    // TODO detail map:
-    float3 detailNormalTS = float3(0.0, 0.0, 0.0);
-    float detailMask = 0.0;
+    // Standard
+    surfaceData.baseColor = SAMPLE_TEXTURE2D_SCALE_BIAS(_BaseColorMap).rgb * _BaseColor.rgb;
+    float3 gradient = SAMPLE_TEXTURE2D_NORMAL_SCALE_BIAS(_NormalMap, float2(_NormalScale.xx));
+    //TODO: bentNormalTS
-    //TODO remove the following and use fetching macros that use uvmapping :
-    //float2 baseColorMapUv = TRANSFORM_TEX(input.texCoord0, _BaseColorMap);
-    //surfaceData.baseColor = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, baseColorMapUv).rgb * _BaseColor.rgb;
-    surfaceData.baseColor = SAMPLE_UVMAPPING_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, layerTexCoord.base).rgb * _BaseColor.rgb;
+    surfaceData.perceptualSmoothnessA = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_SmoothnessAMap), _SmoothnessAMapChannelMask);
+    surfaceData.perceptualSmoothnessA = lerp(_SmoothnessARange.x, _SmoothnessARange.y, surfaceData.perceptualSmoothnessA);
+    surfaceData.perceptualSmoothnessA = lerp(_SmoothnessA, surfaceData.perceptualSmoothnessA, _SmoothnessAUseMap);
+    surfaceData.metallic = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_MetallicMap), _MetallicMapChannelMask);
+    surfaceData.metallic = lerp(_MetallicRange.x, _MetallicRange.y, surfaceData.metallic);
+    surfaceData.metallic = lerp(_Metallic, surfaceData.metallic, _MetallicUseMap);
-    //surfaceData.normalWS = float3(0.0, 0.0, 0.0);
+    surfaceData.dielectricIor = _DielectricIor;
-    normalTS = GetNormalTS(input, layerTexCoord, detailNormalTS, detailMask);
-    //TODO: bentNormalTS
+    surfaceData.ambientOcclusion = dot(SAMPLE_TEXTURE2D_SCALE_BIAS(_AmbientOcclusionMap), _AmbientOcclusionMapChannelMask);
+    surfaceData.ambientOcclusion = lerp(_AmbientOcclusionRange.x, _AmbientOcclusionRange.y, surfaceData.ambientOcclusion);
+    surfaceData.ambientOcclusion = lerp(_AmbientOcclusion, surfaceData.ambientOcclusion, _AmbientOcclusionUseMap);
-#if defined(_SMOOTHNESSMASKMAPA)
-    surfaceData.perceptualSmoothnessA = dot(SAMPLE_UVMAPPING_TEXTURE2D(_SmoothnessAMap, sampler_SmoothnessAMap, layerTexCoord.base), _MetallicMapChannel, _SmoothnessAMapChannel);
-    surfaceData.perceptualSmoothnessA = lerp(_SmoothnessARemap.x, _SmoothnessARemap.y, surfaceData.perceptualSmoothnessA);
+    // These static material feature allow compile time optimization
+    surfaceData.materialFeatures = MATERIALFEATUREFLAGS_STACK_LIT_STANDARD;
+
+    // Feature dependent data
+#ifdef _MATERIAL_FEATURE_DUAL_SPECULAR_LOBE
+    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(_SmoothnessB, surfaceData.perceptualSmoothnessB, _SmoothnessBUseMap);
-    surfaceData.perceptualSmoothnessA = _SmoothnessA;
+    surfaceData.lobeMix = 0.0;
+    surfaceData.perceptualSmoothnessB = 1.0;
-#if defined(_SMOOTHNESSMASKMAPB)
-    surfaceData.perceptualSmoothnessB = dot(SAMPLE_UVMAPPING_TEXTURE2D(_SmoothnessAMaB, sampler_SmoothnessBMap, layerTexCoord.base), _SmoothnessBMapChannel);
-    surfaceData.perceptualSmoothnessB = lerp(_SmoothnessBRemap.x, _SmoothnessBRemap.y, surfaceData.perceptualSmoothnessB);
+#ifdef _MATERIAL_FEATURE_ANISOTROPY
+    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 = _Anisotropy; // In all cases we must multiply anisotropy with the map
-    surfaceData.perceptualSmoothnessB = _SmoothnessB;
+    surfaceData.anisotropy = 0.0;
+    surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
-    // TODOSTACKLIT: lobe weighting
-    surfaceData.lobeMix = _LobeMix;
+#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(_CoatSmoothness, surfaceData.coatPerceptualSmoothness, _CoatSmoothnessUseMap);
+    surfaceData.coatIor = _CoatIor;
+    surfaceData.coatThickness = _CoatThickness;
+    surfaceData.coatExtinction = _CoatExtinction; // in thickness^-1 units
+#else
+    surfaceData.coatPerceptualSmoothness = 0.0;
+    surfaceData.coatIor = 1.0001;
+    surfaceData.coatThickness = 0.0;
+    surfaceData.coatExtinction = float3(1.0, 1.0, 1.0);
+#endif
-    // TODO: Ambient occlusion, detail mask.
-#ifdef _METALLICMAP
-    surfaceData.metallic = dot(SAMPLE_UVMAPPING_TEXTURE2D(_MetallicMap, sampler_MetallicMap, layerTexCoord.base), _MetallicMapChannel);
+#ifdef _MATERIAL_FEATURE_IRIDESCENCE
+    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(_IridescenceThickness, surfaceData.iridescenceThickness, _IridescenceThicknessUseMap);
-    surfaceData.metallic = 1.0;
+    surfaceData.iridescenceIor = 1.0;
+    surfaceData.iridescenceThickness = 0.0;
-    surfaceData.metallic *= _Metallic;
-    // These static material feature allow compile time optimization
-    // TODO: As we add features, or-set the flags eg MATERIALFEATUREFLAGS_LIT_* with #ifdef 
-    // on corresponding _MATERIAL_FEATURE_* shader_feature kerwords (set by UI) so the compiler 
-    // knows the value of surfaceData.materialFeatures.
-    surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
+#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) || defined(_MATERIAL_FEATURE_TRANSMISSION)
+    surfaceData.diffusionProfile = _DiffusionProfile;
+#else
+    surfaceData.diffusionProfile = 0;
+#endif
+
+#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(_SubsurfaceMask, surfaceData.subsurfaceMask, _SubsurfaceMaskUseMap);
+#else
+    surfaceData.subsurfaceMask = 0.0;
+#endif
+
+#ifdef _MATERIAL_FEATURE_TRANSMISSION
+    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(_Thickness, surfaceData.thickness, _ThicknessUseMap);
+#else
+    surfaceData.thickness = 1.0;
+#endif
-    GetNormalWS(input, V, normalTS, surfaceData.normalWS); // MaterialUtilities.hlsl
-
+    // Convert back to world space normal
+    surfaceData.normalWS = SurfaceGradientResolveNormal(input.worldToTangent[2], gradient);
 
     // TODO: decal etc.
 
-        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, layerTexCoord.base.uv, _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.baseColor);
-        surfaceData.metallic = 0;
+        if (_BaseColorMapUV != TEXCOORD_INDEX_TRIPLANAR)
+        {
+            surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, uvMapping.texcoords[_BaseColorMapUV][_BaseColorMapUVLocal], _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.baseColor);
+        }
+        else
+        {
+            surfaceData.baseColor = float3(0.0, 0.0, 0.0);
+        }
+        surfaceData.metallic = 0.0;
     }
 #endif
 
 
-    // NEWLITTODO: for all BuiltinData, might need to just refactor and use a comon function like that 
+    // NEWLITTODO: for all BuiltinData, might need to just refactor and use a comon function like that
-    builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
+    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
-
-#ifdef _EMISSIVE_COLOR_MAP
-    builtinData.emissiveColor *= SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb;
-#endif
+    builtinData.emissiveColor *= SAMPLE_TEXTURE2D_SCALE_BIAS(_EmissiveColorMap).rgb;
+    // TODO:
-    
-    //NEWLITTODO: shader feature SHADOWS_SHADOWMASK not there yet. 
+#ifdef SHADOWS_SHADOWMASK
+    float4 shadowMask = SampleShadowMask(input.positionWS, input.texCoord1);
+    builtinData.shadowMask0 = shadowMask.x;
+    builtinData.shadowMask1 = shadowMask.y;
+    builtinData.shadowMask2 = shadowMask.z;
+    builtinData.shadowMask3 = shadowMask.w;
+#else
+#endif
 
 #if (SHADERPASS == SHADERPASS_DISTORTION) || defined(DEBUG_DISPLAY)
     float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
 #endif
 
     builtinData.depthOffset = 0.0;
-
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl

 TEXTURE2D(_BaseColorMap);
 SAMPLER(sampler_BaseColorMap);
 
+TEXTURE2D(_AmbientOcclusionMap);
+SAMPLER(sampler_AmbientOcclusionMap);
+
 TEXTURE2D(_MetallicMap);
 SAMPLER(sampler_MetallicMap);
 
+TEXTURE2D(_NormalMap);
+SAMPLER(sampler_NormalMap);
+
+TEXTURE2D(_AnisotropyMap);
+SAMPLER(sampler_AnisotropyMap);
+
+TEXTURE2D(_CoatSmoothnessMap);
+SAMPLER(sampler_CoatSmoothnessMap);
+
+TEXTURE2D(_IridescenceThicknessMap);
+SAMPLER(sampler_IridescenceThicknessMap);
+
+TEXTURE2D(_SubsurfaceMaskMap);
+SAMPLER(sampler_SubsurfaceMaskMap);
+
+TEXTURE2D(_ThicknessMap);
+SAMPLER(sampler_ThicknessMap);
+
-TEXTURE2D(_NormalMap);
-SAMPLER(sampler_NormalMap);
-
-
 CBUFFER_START(UnityPerMaterial)
 
 float4 _BaseColor;
 float _BaseColorMapUV;
+float _BaseColorMapUVLocal;
+float _MetallicUseMap;
-float4 _MetallicMapChannel;
+float _MetallicMapUVLocal;
+float4 _MetallicMap_ST;
+float4 _MetallicMap_TexelSize;
+float4 _MetallicMap_MipInfo;
+float4 _MetallicMapChannelMask;
+float4 _MetallicRange;
+
+float _DielectricIor;
+float _SmoothnessAUseMap;
-float4 _SmoothnessAMapChannel;
-float4 _SmoothnessARemap;
-float _SmoothnessB;
-float _SmoothnessBUV;
-float4 _SmoothnessBMapChannel;
-float4 _SmoothnessBRemap;
-float _LobeMix;
+float _SmoothnessAMapUVLocal;
+float4 _SmoothnessAMap_ST;
+float4 _SmoothnessAMap_TexelSize;
+float4 _SmoothnessAMap_MipInfo;
+float4 _SmoothnessAMapChannelMask;
+float4 _SmoothnessARange;
+
+float4 _DebugLobeMask;
+float4 _DebugAniso;
+float _NormalMapUVLocal;
+float _NormalMapObjSpace;
+float4 _NormalMap_ST;
+float4 _NormalMap_TexelSize;
+float4 _NormalMap_MipInfo;
-float4 _UVMappingMask;
+float _AmbientOcclusion;
+float _AmbientOcclusionUseMap;
+float _AmbientOcclusionMapUV;
+float _AmbientOcclusionMapUVLocal;
+float4 _AmbientOcclusionMap_ST;
+float4 _AmbientOcclusionMap_TexelSize;
+float4 _AmbientOcclusionMap_MipInfo;
+float4 _AmbientOcclusionMapChannelMask;
+float4 _AmbientOcclusionRange;
+float _SmoothnessB;
+float _SmoothnessBUseMap;
+float _SmoothnessBMapUV;
+float _SmoothnessBMapUVLocal;
+float4 _SmoothnessBMap_ST;
+float4 _SmoothnessBMap_TexelSize;
+float4 _SmoothnessBMap_MipInfo;
+float4 _SmoothnessBMapChannelMask;
+float4 _SmoothnessBRange;
+float _LobeMix;
+
+float _Anisotropy;
+float _AnisotropyUseMap;
+float _AnisotropyMapUV;
+float _AnisotropyMapUVLocal;
+float4 _AnisotropyMap_ST;
+float4 _AnisotropyMap_TexelSize;
+float4 _AnisotropyMap_MipInfo;
+float4 _AnisotropyMapChannelMask;
+float4 _AnisotropyRange;
+
+float _CoatSmoothness;
+float _CoatSmoothnessUseMap;
+float _CoatSmoothnessMapUV;
+float _CoatSmoothnessMapUVLocal;
+float4 _CoatSmoothnessMap_ST;
+float4 _CoatSmoothnessMap_TexelSize;
+float4 _CoatSmoothnessMap_MipInfo;
+float4 _CoatSmoothnessMapChannelMask;
+float4 _CoatSmoothnessRange;
+float _CoatIor;
+float _CoatThickness;
+float3 _CoatExtinction;
+
+float _IridescenceThickness;
+float _IridescenceThicknessUseMap;
+float _IridescenceThicknessMapUV;
+float _IridescenceThicknessMapUVLocal;
+float4 _IridescenceThicknessMap_ST;
+float4 _IridescenceThicknessMap_TexelSize;
+float4 _IridescenceThicknessMap_MipInfo;
+float4 _IridescenceThicknessMapChannelMask;
+float4 _IridescenceThicknessRange;
+float _IridescenceIor;
+
+int _DiffusionProfile;
+float _SubsurfaceMask;
+float _SubsurfaceMaskUseMap;
+float _SubsurfaceMaskMapUV;
+float _SubsurfaceMaskMapUVLocal;
+float4 _SubsurfaceMaskMap_ST;
+float4 _SubsurfaceMaskMap_TexelSize;
+float4 _SubsurfaceMaskMap_MipInfo;
+float4 _SubsurfaceMaskMapChannelMask;
+float4 _SubsurfaceMaskRange;
+
+float _Thickness;
+float _ThicknessUseMap;
+float _ThicknessMapUV;
+float _ThicknessMapUVLocal;
+float4 _ThicknessMap_ST;
+float4 _ThicknessMap_TexelSize;
+float4 _ThicknessMap_MipInfo;
+float4 _ThicknessMapChannelMask;
+float4 _ThicknessRange;
+float4 _EmissiveColorMap_TexelSize;
+float4 _EmissiveColorMap_MipInfo;
+float _EmissiveColorMapUV;
+float _EmissiveColorMapUVLocal;
 float _EmissiveIntensity;
 float _AlbedoAffectEmissive;
 
 float _DistortionBlurScale;
 float _DistortionBlurRemapMin;
 float _DistortionBlurRemapMax;
-
 
 // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
 // value that exist to identify if the GI emission need to be enabled.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/CombineLighting.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
             // #pragma enable_d3d11_debug_symbols
 
             #pragma vertex Vert

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.compute

-// =============== Convolves transmitted radiance with the Disney diffusion profile ================
+// =============== Convolves transmitted radiance with the Disney diffusion profile ================
 
 //--------------------------------------------------------------------------------------------------
 // Definitions
 #include "../../Lighting/LightDefinition.cs.hlsl"
 #include "SubsurfaceScattering.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
             // #pragma enable_d3d11_debug_symbols
 
             #pragma vertex Vert

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.shader

     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     //-------------------------------------------------------------------------------------
     // Variant

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

-using System;
+using System;
 using System.Collections.Generic;
 using UnityEngine.XR;
 
             // Planar and real time cubemap doesn't need post process and render in FP16
             aggregate.enablePostprocess = camera.cameraType != CameraType.Reflection && srcFrameSettings.enablePostprocess;
 
+#if UNITY_SWITCH
+            aggregate.enableStereo = false;
+#else
+#endif
 
             aggregate.enableAsyncCompute = srcFrameSettings.enableAsyncCompute && SystemInfo.supportsAsyncCompute;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ApplyDistorsion.compute

-#include "CoreRP/ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 TEXTURE2D(_DistortionTexture);
 TEXTURE2D(_ColorPyramidTexture);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/Blit.shader

-Shader "Hidden/HDRenderPipeline/Blit"
+Shader "Hidden/HDRenderPipeline/Blit"
-        #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+        #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
         #include "CoreRP/ShaderLibrary/Common.hlsl"
         #include "../ShaderVariables.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramidProcessor.cs

 
                 cmd.SetComputeTextureParam(m_DepthPyramidCS, kernel, _Source, src);
                 cmd.SetComputeTextureParam(m_DepthPyramidCS, kernel, _Result, dest);
+                // The compute shader work in texture space
+                // So we must provide the texture's size
-                    srcWorkMip.width, srcWorkMip.height,
-                    (1.0f / srcMip.width) * scale.x, (1.0f / srcMip.height) * scale.y)
+                    src.rt.width, src.rt.height,
+                    (1.0f / src.rt.width), (1.0f / src.rt.height))
                 );
 
                 cmd.DispatchCompute(
                     1
                 );
 
-                var dstMipWidthToCopy = Mathf.Min(targetTexture.rt.width >> (i + 1), dstWorkMip.width);
-                var dstMipHeightToCopy = Mathf.Min(targetTexture.rt.height >> (i + 1), dstWorkMip.height);
+                var dstMipWidthToCopy = Mathf.Min(Mathf.Min(targetTexture.rt.width >> (i + 1), dstWorkMip.width), mips[i].rt.width);
+                var dstMipHeightToCopy = Mathf.Min(Mathf.Min(targetTexture.rt.height >> (i + 1), dstWorkMip.height), mips[i].rt.height);
 
                 // If we could bind texture mips as UAV we could avoid this copy...(which moreover copies more than the needed viewport if not fullscreen)
                 cmd.CopyTexture(mips[i], 0, 0, 0, 0, dstMipWidthToCopy, dstMipHeightToCopy, targetTexture, 0, i + 1, 0, 0);
                 cmd.SetComputeVectorParam(
                     m_ColorPyramidCS,
                     _Size,
-                    new Vector4(dest.width, dest.height, 1f / dest.width, 1f / dest.height)
+                    new Vector4(src.width >> 1, src.height >> 1, 1f / (src.width >> 1), 1f / (src.height >> 1))
                 );
                 cmd.DispatchCompute(
                     m_ColorPyramidCS,
                     1
                 );
 
-                var dstMipWidthToCopy = Mathf.Min(targetTexture.width >> (i + 1), dstWorkMip.width);
-                var dstMipHeightToCopy = Mathf.Min(targetTexture.height >> (i + 1), dstWorkMip.height);
+                var dstMipWidthToCopy = Mathf.Min(Mathf.Min(targetTexture.width >> (i + 1), dstWorkMip.width), mips[i].width);
+                var dstMipHeightToCopy = Mathf.Min(Mathf.Min(targetTexture.height >> (i + 1), dstWorkMip.height), mips[i].height);
 
                 // If we could bind texture mips as UAV we could avoid this copy...(which moreover copies more than the needed viewport if not fullscreen)
                 cmd.CopyTexture(

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ColorPyramid.compute

 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 Texture2D<float4> _Source;
 RWTexture2D<float4> _Result;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/CopyDepthBuffer.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
             #pragma fragment Frag
             #pragma vertex Vert
             // #pragma enable_d3d11_debug_symbols

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/CopyStencilBuffer.shader

     HLSLINCLUDE
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
     // #pragma enable_d3d11_debug_symbols
 
     #include "CoreRP/ShaderLibrary/Common.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DepthPyramid.compute

-#include "CoreRP/ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
 
 // ------------------------------------------------
 // Algorithm
 #pragma kernel KDepthDownSample8                  KERNEL_SIZE=8       KERNEL_NAME=KDepthDownSample8    
 #pragma kernel KDepthDownSample1                  KERNEL_SIZE=1       KERNEL_NAME=KDepthDownSample1
 
-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 // ------------------------------------------------
 // Texture buffers

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   hdriSky: {fileID: 4800000, guid: 9bd32a6ece529fd4f9408b8d7e00c10d, type: 3}
   proceduralSky: {fileID: 4800000, guid: ec63f47fd265df243a7b1d40f9ef7fe7, type: 3}
   skyboxCubemap: {fileID: 103, guid: 0000000000000000f000000000000000, type: 0}
+  preIntegratedFGD: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad, type: 3}
   encodeBC6HCS: {fileID: 7200000, guid: aa922d239de60304f964e24488559eeb, type: 3}
   cubeToPanoShader: {fileID: 4800000, guid: 595434cc3b6405246b6cd3086d0b6f7d, type: 3}
   blitCubeTextureFace: {fileID: 4800000, guid: d850d0a2481878d4bbf17e5126b04163, type: 3}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

         public Shader opaqueAtmosphericScattering;
         public Shader hdriSky;
         public Shader proceduralSky;
-
+
+        // Material
+        public Shader preIntegratedFGD;
 
         // Utilities / Core
         public ComputeShader encodeBC6HCS;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariablesFunctions.hlsl

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/HDRISky/HDRISky.shader

     #pragma fragment Frag
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     #include "CoreRP/ShaderLibrary/Common.hlsl"
     #include "CoreRP/ShaderLibrary/Color.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/OpaqueAtmosphericScattering.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
             #pragma vertex Vert
             #pragma fragment Frag

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/ProceduralSky/ProceduralSky.shader

     #pragma fragment Frag
 
     #pragma target 4.5
-    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
     #pragma multi_compile _ _ENABLE_SUN_DISK
 

ScriptableRenderPipeline/HDRenderPipeline/LICENSE.md

-**Unity Companion Package License v1.0 ("_License_")**
-
-Copyright © 2017 Unity Technologies ApS ("**_Unity_**")
-
-Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License ("**_Software_**"), subject to the following terms and conditions:
-
-1. *Unity Companion Use Only*. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license ("**_Engine License_**"). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
-
-1. *No Modification of Engine License*. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
-
-1. *Ownership & Grant Back to You*. 
-
-    3.1. You own your content. In this License, "derivative works" means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-    3.2. Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-    3.3. You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
-
-1. *Trademarks*. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates ("**_Trademarks_**"). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at [https://unity3d.com/public-relations/brand](https://unity3d.com/public-relations/brand).
-
-1. *Notices & Third-Party Rights*. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity "third-party notices" or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
-
-1. *DISCLAIMER, LIMITATION OF LIABILITY*. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-1. *USE IS ACCEPTANCE and License Versions*. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
-
-1. *Use in Compliance with Law and Termination*. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+High Definition Render Pipeline copyright © 2018 Unity Technologies ApS
-1. *Severability*. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License). 
-1. *Governing Law and Venue*. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License ("**_Dispute_**"). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.